def setUp(self):
natoms = 10
minimiser = PeleMinimiser(lj.LJ())
factory = ClusterFactory(natoms, minimiser)
self.population = PopulationList(natoms, factory, max_size=5)
while len(self.population) < self.population.max_size:
self.population.append(factory.get_random_cluster())
def test(): # pragma: no cover
from _orthogopt import orthogopt_slow, orthogopt
natoms = 105
for i in xrange(1):
x = np.random.random(3 * natoms) * 5
xx = x.reshape(-1, 3)
com = xx.sum(0) / xx.shape[0]
xx -= com
v = np.random.random(3 * natoms)
test1 = orthogopt_slow(v.copy(), x.copy())
ozev = gramm_schmidt(zeroEV_cluster(x))
orthogonalize(v, ozev)
print np.linalg.norm(v - test1)
exit()
from pele.potentials import lj
pot = lj.LJ()
x = np.array([-1., 0., 0., 1., 0., 0., 0., 1., 1., 0., -1., -1.])
x = np.random.random(x.shape)
print x
v = zeroEV_cluster(x)
print np.dot(v[0], v[1]), np.dot(v[0], v[2]), np.dot(v[1], v[2])
print np.dot(v[3], v[4]), np.dot(v[3], v[5]), np.dot(v[5], v[4])
u = gramm_schmidt(zeroEV_cluster(x))
for i in u:
print (pot.getEnergy(x + 1e-4 * i) - pot.getEnergy(x)) / 1e-4, i
print np.dot(u[3], u[4]), np.dot(u[3], u[5]), np.dot(u[5], u[4])
print "########################"
r = np.random.random(x.shape)
print orthogopt(r.copy(), x.copy()) - orthogonalize(r.copy(), u)
def test_replace(self):
natoms=10
minimiser=PeleMinimiser(lj.LJ())
factory=ClusterFactory(natoms,minimiser)
parent = factory.get_random_cluster()
mutator = MutateReplace()
mutant = mutator.get_mutant(parent)
self.assertLess(mutant.get_energy(), 0)
def test_mutant(self):
natoms = 10
minimiser = PeleMinimiser(lj.LJ())
factory = ClusterFactory(natoms, minimiser)
parent_a = factory.get_random_cluster()
parent_b = factory.get_random_cluster()
crossover = DeavenHo()
offspring = crossover.get_offspring(parent_a, parent_b)
self.assertLess(offspring.get_energy(), 0)
def takeStep(self, coords, **kwargs):
# make a new monte carlo class
mc = MonteCarlo(coords, self.potential, self.mcstep,
temperature=self.T, outstream=None)
mc.run(self.nsteps)
coords[:] = mc.coords[:]
def updateStep(self, acc, **kwargs):
pass
natoms = 12
# random initial coordinates
coords = np.random.random(3 * natoms)
potential = lj.LJ()
step = TakeStepMonteCarlo(potential)
opt = bh.BasinHopping(coords, potential, takeStep=step)
opt.run(100)
# some visualization
try:
import pele.utils.pymolwrapper as pym
pym.start()
pym.draw_spheres(opt.coords, "A", 1)
except:
print("Could not draw using pymol, skipping this step")
############################################################
# Just quench
############################################################
import numpy as np
import pele.potentials.lj as lj
natoms = 12
# random initial coordinates
coords=np.random.random(3*natoms)
pot = lj.LJ()
print pot.getEnergy(coords)
a,b = pot.getEnergyGradient(coords)
print type(a)
from pele.optimize import lbfgs_scipy, cg fire
# lbfgs
ret = lbfgs_scipy( coords, pot, iprint=-1 , tol = 1e-3, nsteps=100)
# core dump!
# cg
# ret = cg( coordsVec, pot.getEnergyGradient)
# runtime error -- ValueError: The truth value of an array with more than ...
# fire
#ret = fire( coords, pot.getEnergyGradient, tol = 1e-3, nsteps=20000)
# ValueError: The truth value of an array with more than ...
def setUp(self):
self.natoms = 3
minimiser = PeleMinimiser(lj.LJ())
coords = np.array(((0., 0., 0.1), (0.1, 0.1, 0.1), (0., 0.2, 0.2)))
self.cluster = Cluster(self.natoms, coords, minimiser)
def setUp(self):
natoms = 3
self.minimiser = PeleMinimiser(lj.LJ())
coords = np.array(((0., 0., 0.1), (1., 1., 0.3), (0., 2., 0.2)))
self.cluster = Cluster(natoms, coords, self.minimiser)
'''
A simple GA run. We use a 38 atom Lennard-Jones in this example.
The natoms argument defines the number of atoms in the cluster and is required for all GA searchs.
The minimiser object is also needed to perform the energy evaluations. This example uses a simple
Lennard-Jones minimiser. Other examples show how to set up minimisers for more complicated potentials.
@author: Mark Oakley
'''
from bcga.genetic_algorithm import GeneticAlgorithm
import pele.potentials.lj as lj
from bcga.pele_interface import PeleMinimiser
myga = GeneticAlgorithm(
natoms=38, # Number of atoms
minimiser=PeleMinimiser(lj.LJ())) #Energy minimisation method
myga.run()
def setUp(self):
natoms = 10
minimiser = PeleMinimiser(lj.LJ())
self.ga = GeneticAlgorithm(natoms, minimiser, max_generation=2)
def setUp(self):
natoms = 10
minimiser = PeleMinimiser(lj.LJ())
self.factory = ClusterFactory(natoms, minimiser)
def runptmc(nsteps_tot=100000):
natoms = 31
nreplicas = 4
Tmin = 0.2
Tmax = 0.4
nsteps_equil = 10000
nsteps_tot = 100000
histiprint = nsteps_tot / 10
exchange_frq = 100 * nreplicas
coords = np.random.random(3 * natoms)
#quench the coords so we start from a reasonable location
mypot = lj.LJ()
ret = quench(coords, mypot)
coords = ret.coords
Tlist = getTemps(Tmin, Tmax, nreplicas)
replicas = []
ostreams = []
histograms = []
takesteplist = []
radius = 2.5
# create all the replicas which will be passed to PTMC
for i in range(nreplicas):
T = Tlist[i]
potential = lj.LJ()
takestep = RandomDisplacement(stepsize=0.01)
adaptive = AdaptiveStepsize(takestep, last_step=nsteps_equil)
takesteplist.append(adaptive)
file = "mcout." + str(i + 1)
ostream = open(file, "w")
hist = EnergyHistogram(-134., 10., 1000)
histograms.append(hist)
event_after_step = [hist]
radiustest = SphericalContainer(radius)
accept_tests = [radiustest]
mc = MonteCarlo(coords, potential, takeStep=takestep, temperature=T, \
outstream=ostream, event_after_step = event_after_step, \
confCheck = accept_tests)
mc.histogram = hist #for convienence
mc.printfrq = 1
replicas.append(mc)
#is it possible to pickle a mc object?
#cp = copy.deepcopy(replicas[0])
#import pickle
#with open("mc.pickle", "w") as fout:
#pickle.dump(takesteplist[0], fout)
#attach an event to print xyz coords
from pele.printing.print_atoms_xyz import PrintEvent
printxyzlist = []
for n, rep in enumerate(replicas):
outf = "dumpstruct.%d.xyz" % (n + 1)
printxyz = PrintEvent(outf, frq=500)
printxyzlist.append(printxyz)
rep.addEventAfterStep(printxyz)
#attach an event to print histograms
for n, rep in enumerate(replicas):
outf = "hist.%d" % (n + 1)
histprint = PrintHistogram(outf, rep.histogram, histiprint)
rep.addEventAfterStep(histprint)
ptmc = PTMC(replicas)
ptmc.use_independent_exchange = True
ptmc.exchange_frq = exchange_frq
ptmc.run(nsteps_tot)
#do production run
#fix the step sizes
#for takestep in takesteplist:
# takestep.useFixedStep()
#ptmc.run(30000)
if False: #this doesn't work
print "final energies"
for rep in ptmc.replicas:
print rep.temperature, rep.markovE
for rep in ptmc.replicas_par:
print rep.mcsys.markovE
for k in range(nreplicas):
e, T = ptmc.getRepEnergyT(k)
print T, e
if False: #this doesn't work
print "histograms"
for i, hist in enumerate(histograms):
fname = "hist." + str(i)
print fname
with open(fname, "w") as fout:
for (e, visits) in hist:
fout.write("%g %d\n" % (e, visits))
ptmc.end() #close the open threads
'''
The batch GA is designed to be used in conjunction with a task arrays on a
scheduling system. The population of structures is stored in an SQL database
that can be accessed by several instances of the GA at the same time.
For this example, we use a simple Lennard-Jones potential. However, the batch
GA is designed to be most useful for very expensive energy calculations (e.g.
DFT).
Use the read_database script to view the database in a human-readable format.
@author: Mark Oakley
'''
from bcga.batch_genetic_algorithm import BatchGeneticAlgorithm
from bcga.pele_interface import PeleMinimiser
import pele.potentials.lj as lj
natoms = 38
minimiser=PeleMinimiser(lj.LJ())
myga = BatchGeneticAlgorithm(natoms,
minimiser,
remove_duplicates=True,
max_generation=20)
myga.run()
