def prepare_startGenerator():
cell = np.array([[24, 0, 0],
[0, 24, 0],
[0, 0, 24]])
pbc = [False, False, False]
# Define template
slab = Atoms('',
cell=cell,
pbc=pbc)
# Define the box to place the atoms within
# The volume is defined by a corner position (p0) and three spanning vectors (v)
v = np.array([[4, 0, 0],
[0, 4, 0],
[0, 0, 4]])
p0 = np.diag((cell-v)/2)
# Define the composition of the atoms to optimize
atom_numbers = [6]*24 # 24 carbon atoms
# define the closest distance two atoms of a given species can be to each other
unique_atom_types = get_all_atom_types(slab, atom_numbers)
cd = closest_distances_generator(atom_numbers=unique_atom_types,
ratio_of_covalent_radii=0.7)
# create the starting population
sg = StartGenerator(slab = slab,
atom_numbers = atom_numbers,
closest_allowed_distances = cd,
box_to_place_in = [p0, v],
elliptic = False,
cluster = True)
return sg
def ga_init(self, ddiff, dmax, dE):
self.ddiff = ddiff
self.dmax = dmax
self.dE = dE
da = DataConnection(self.db_name)
atom_numbers_to_optimize = da.get_atom_numbers_to_optimize(
) # adsorbate atom numbers to optimize
n_to_optimize = len(
atom_numbers_to_optimize) # number of atoms to optimize
slab = da.get_slab()
all_atom_types = get_all_atom_types(slab, atom_numbers_to_optimize)
blmin = closest_distances_generator(
all_atom_types,
ratio_of_covalent_radii=.7) # closest distance atoms can be
comp = InteratomicDistanceComparator(
n_top=None,
pair_cor_cum_diff=self.ddiff,
pair_cor_max=dmax,
dE=dE,
mic=True) # comparator to determine if parents should make childer
pairing = CutAndSplicePairing(
blmin, None, use_tags=True, p1=.2
) # how children are generated (make sure your adsorbates are uniquely tagged)
population = Population(data_connection=da,
population_size=self.pop,
comparator=comp)
for i in range(self.n_to_test):
print('Now starting configuration number {0}'.format(i))
a1, a2 = population.get_two_candidates()
a3, desc = pairing.get_new_individual([a1, a2])
#print(a3.info)
#view(a3)
if a3 is None:
continue
da.add_unrelaxed_candidate(a3, description=desc)
from ase.ga.offspring_creator import OperationSelector
from ase.ga.standardmutations import MirrorMutation
from ase.ga.standardmutations import RattleMutation
from ase.ga.standardmutations import PermutationMutation
# Change the following three parameters to suit your needs
population_size = 20
mutation_probability = 0.3
n_to_test = 20
# Initialize the different components of the GA
da = DataConnection('gadb.db')
atom_numbers_to_optimize = da.get_atom_numbers_to_optimize()
n_to_optimize = len(atom_numbers_to_optimize)
slab = da.get_slab()
all_atom_types = get_all_atom_types(slab, atom_numbers_to_optimize)
blmin = closest_distances_generator(all_atom_types,
ratio_of_covalent_radii=0.7)
comp = InteratomicDistanceComparator(n_top=n_to_optimize,
pair_cor_cum_diff=0.015,
pair_cor_max=0.7,
dE=0.02,
mic=False)
pairing = CutAndSplicePairing(slab, n_to_optimize, blmin)
mutations = OperationSelector([1., 1., 1.], [
MirrorMutation(blmin, n_to_optimize),
RattleMutation(blmin, n_to_optimize),
PermutationMutation(n_to_optimize)
])
from ase.ga.offspring_creator import OperationSelector
from ase.ga.standardmutations import MirrorMutation
from ase.ga.standardmutations import RattleMutation
from ase.ga.standardmutations import PermutationMutation
# Change the following three parameters to suit your needs
population_size = 5
mutation_probability = 0.3
n_to_test = 5
# Initialize the different components of the GA
da = DataConnection("gadb.db")
atom_numbers_to_optimize = da.get_atom_numbers_to_optimize()
n_to_optimize = len(atom_numbers_to_optimize)
slab = da.get_slab()
all_atom_types = get_all_atom_types(slab, atom_numbers_to_optimize)
blmin = closest_distances_generator(all_atom_types, ratio_of_covalent_radii=0.7)
comp = InteratomicDistanceComparator(n_top=n_to_optimize, pair_cor_cum_diff=0.015, pair_cor_max=0.7, dE=0.02, mic=False)
pairing = CutAndSplicePairing(slab, n_to_optimize, blmin)
mutations = OperationSelector(
[1.0, 1.0, 1.0],
[MirrorMutation(blmin, n_to_optimize), RattleMutation(blmin, n_to_optimize), PermutationMutation(n_to_optimize)],
)
# Relax all unrelaxed structures (e.g. the starting population)
while da.get_number_of_unrelaxed_candidates() > 0:
a = da.get_an_unrelaxed_candidate()
a.set_calculator(EMT())
print("Relaxing starting candidate {0}".format(a.info["confid"]))
# define the volume in which the adsorbed cluster is optimized
# the volume is defined by a corner position (p0)
# and three spanning vectors (v1, v2, v3)
pos = slab.get_positions()
cell = slab.get_cell()
p0 = np.array([0., 0., max(pos[:, 2]) + 2.])
v1 = cell[0, :] * 0.8
v2 = cell[1, :] * 0.8
v3 = cell[2, :]
v3[2] = 3.
# Define the composition of the atoms to optimize
atom_numbers = 2 * [47] + 2 * [79]
# define the closest distance two atoms of a given species can be to each other
unique_atom_types = get_all_atom_types(slab, atom_numbers)
blmin = closest_distances_generator(atom_numbers=unique_atom_types,
ratio_of_covalent_radii=0.7)
# create the starting population
sg = StartGenerator(slab,
atom_numbers,
blmin,
box_to_place_in=[p0, [v1, v2, v3]])
# generate the starting population
population_size = 20
starting_population = [sg.get_new_candidate() for i in range(population_size)]
# from ase.visualize import view # uncomment these lines
# view(starting_population) # to see the starting population
# define the volume in which the adsorbed cluster is optimized
# the volume is defined by a corner position (p0)
# and three spanning vectors (v1, v2, v3)
pos = slab.get_positions()
cell = slab.get_cell()
p0 = np.array([0., 0., max(pos[:, 2]) + 2.])
v1 = cell[0, :] * 0.8
v2 = cell[1, :] * 0.8
v3 = cell[2, :]
v3[2] = 3.
# Define the composition of the atoms to optimize
atom_numbers = 2 * [47] + 2 * [79]
# define the closest distance two atoms of a given species can be to each other
unique_atom_types = get_all_atom_types(slab, atom_numbers)
cd = closest_distances_generator(atom_numbers=unique_atom_types,
ratio_of_covalent_radii=0.7)
# create the starting population
sg = StartGenerator(slab=slab,
atom_numbers=atom_numbers,
closest_allowed_distances=cd,
box_to_place_in=[p0, [v1, v2, v3]])
# generate the starting population
population_size = 5
starting_population = [sg.get_new_candidate() for i in xrange(population_size)]
# from ase.visualize import view # uncomment these lines
# view(starting_population) # to see the starting population
def run_ga(n_to_test, kptdensity=3.5):
population_size = 20
da = DataConnection('godb.db')
atom_numbers_to_optimize = da.get_atom_numbers_to_optimize()
n_to_optimize = len(atom_numbers_to_optimize)
slab = da.get_slab()
all_atom_types = get_all_atom_types(slab, atom_numbers_to_optimize)
blmin = closest_distances_generator(all_atom_types, 0.05) # 0.5
# defining genetic operators:
mutation_probability = 0.75
pairing = CutAndSplicePairing(blmin,
p1=1.,
p2=0.,
minfrac=0.15,
use_tags=False)
cellbounds = CellBounds(
bounds={
'phi': [0.2 * 180., 0.8 * 180.],
'chi': [0.2 * 180., 0.8 * 180.],
'psi': [0.2 * 180., 0.8 * 180.]
})
strainmut = StrainMutation(blmin,
stddev=0.7,
cellbounds=cellbounds,
use_tags=False)
blmin_soft = closest_distances_generator(all_atom_types, 0.1)
softmut = SoftMutation(blmin_soft, bounds=[2., 5.], use_tags=False)
rattlemut = RattleMutation(blmin,
n_to_optimize,
rattle_prop=0.8,
rattle_strength=2.5,
use_tags=False)
mutations = OperationSelector([4., 4., 2], [softmut, strainmut, rattlemut])
if True:
# recalculate raw scores
structures = da.get_all_relaxed_candidates()
for atoms in structures:
atoms = singlepoint(atoms, kptdensity=kptdensity)
da.c.delete([atoms.info['relax_id']])
if 'data' not in atoms.info:
atoms.info['data'] = {}
da.add_relaxed_step(atoms)
print('Finished recalculating raw scores')
# relaxing the initial candidates:
while da.get_number_of_unrelaxed_candidates() > 0:
a = da.get_an_unrelaxed_candidate()
a.wrap()
a = relax_one(a, kptdensity=kptdensity)
da.add_relaxed_step(a)
# create the population
population = Population(data_connection=da,
population_size=population_size,
comparator=comparator,
logfile='log.txt')
current_pop = population.get_current_population()
strainmut.update_scaling_volume(current_pop, w_adapt=0.5, n_adapt=4)
pairing.update_scaling_volume(current_pop, w_adapt=0.5, n_adapt=4)
# Test n_to_test new candidates
ga_raw_scores = []
step = 0
for step in range(n_to_test):
print('Starting configuration number %d' % step, flush=True)
clock = time()
a3 = None
r = random()
if r > mutation_probability:
while a3 is None:
a1, a2 = population.get_two_candidates()
a3, desc = pairing.get_new_individual([a1, a2])
else:
while a3 is None:
a1 = population.get_one_candidate()
a3, desc = mutations.get_new_individual([a1])
dt = time() - clock
op = 'pairing' if r > mutation_probability else 'mutating'
print('Time for %s candidate(s): %.3f' % (op, dt), flush=True)
a3.wrap()
da.add_unrelaxed_candidate(a3, description=desc)
a3 = relax_one(a3, kptdensity=kptdensity)
da.add_relaxed_step(a3)
# Various updates:
population.update()
current_pop = population.get_current_population()
if step % 10 == 0:
strainmut.update_scaling_volume(current_pop,
w_adapt=0.5,
n_adapt=4)
pairing.update_scaling_volume(current_pop, w_adapt=0.5, n_adapt=4)
write('current_population.traj', current_pop)
# Print out information for easy analysis/plotting afterwards:
if r > mutation_probability:
print('Step %d %s %.3f %.3f %.3f' % (step, desc,\
get_raw_score(a1), get_raw_score(a2), get_raw_score(a3)))
else:
print('Step %d %s %.3f %.3f' % (step, desc,\
get_raw_score(a1), get_raw_score(a3)))
print('Step %d highest raw score in pop: %.3f' % \
(step, get_raw_score(current_pop[0])))
ga_raw_scores.append(get_raw_score(a3))
print('Step %d highest raw score generated by GA: %.3f' % \
(step, max(ga_raw_scores)))
emin = population.pop[0].get_potential_energy()
print('GA finished after step %d' % step)
print('Lowest energy = %8.3f eV' % emin, flush=True)
write('all_candidates.traj', da.get_all_relaxed_candidates())
write('current_population.traj', population.get_current_population())
def run_ga(n_to_test, kptdensity=None):
''' This method specifies how to run the GA once the
initial random structures have been stored in godb.db.
'''
# Various initializations:
population_size = 10
da = DataConnection('godb.db')
atom_numbers_to_optimize = da.get_atom_numbers_to_optimize()
n_to_optimize = len(atom_numbers_to_optimize)
slab = da.get_slab()
all_atom_types = get_all_atom_types(slab, atom_numbers_to_optimize)
blmin = closest_distances_generator(all_atom_types,
ratio_of_covalent_radii=0.05)
# Defining the mix of genetic operators:
mutation_probability = 0.3333
pairing = CutAndSplicePairing(slab, n_to_optimize, blmin)
rattlemut = RattleMutation(blmin, n_to_optimize,
rattle_prop=0.8, rattle_strength=1.5)
mirrormut = MirrorMutation(blmin, n_to_optimize)
mutations = OperationSelector([1., 1.], [rattlemut, mirrormut])
if True:
# Recalculate raw scores of any relaxed candidates
# present in the godb.db database (only applies to
# iter007).
structures = da.get_all_relaxed_candidates()
for atoms in structures:
atoms = singlepoint(atoms)
da.c.delete([atoms.info['relax_id']])
if 'data' not in atoms.info:
atoms.info['data'] = {}
da.add_relaxed_step(atoms)
print('Finished recalculating raw scores')
# Relax the randomly generated initial candidates:
while da.get_number_of_unrelaxed_candidates() > 0:
a = da.get_an_unrelaxed_candidate()
a.wrap()
a = relax_one(a)
da.add_relaxed_step(a)
# Create the population
population = Population(data_connection=da,
population_size=population_size,
comparator=comparator,
logfile='log.txt')
current_pop = population.get_current_population()
# Test n_to_test new candidates
ga_raw_scores = []
step = 0
for step in range(n_to_test):
print('Starting configuration number %d' % step, flush=True)
clock = time()
a3 = None
r = random()
if r > mutation_probability:
while a3 is None:
a1, a2 = population.get_two_candidates()
a3, desc = pairing.get_new_individual([a1, a2])
else:
while a3 is None:
a1 = population.get_one_candidate()
a3, desc = mutations.get_new_individual([a1])
dt = time() - clock
op = 'pairing' if r > mutation_probability else 'mutating'
print('Time for %s candidate(s): %.3f' % (op, dt), flush=True)
a3.wrap()
da.add_unrelaxed_candidate(a3, description=desc)
a3 = relax_one(a3)
da.add_relaxed_step(a3)
# Various updates:
population.update()
current_pop = population.get_current_population()
write('current_population.traj', current_pop)
# Print out information for easy analysis/plotting afterwards:
if r > mutation_probability:
print('Step %d %s %.3f %.3f %.3f' % (step, desc,\
get_raw_score(a1), get_raw_score(a2), get_raw_score(a3)))
else:
print('Step %d %s %.3f %.3f' % (step, desc,\
get_raw_score(a1), get_raw_score(a3)))
print('Step %d highest raw score in pop: %.3f' % \
(step, get_raw_score(current_pop[0])))
ga_raw_scores.append(get_raw_score(a3))
print('Step %d highest raw score generated by GA: %.3f' % \
(step, max(ga_raw_scores)))
emin = population.pop[0].get_potential_energy()
print('GA finished after step %d' % step)
print('Lowest energy = %8.3f eV' % emin, flush=True)
write('all_candidates.traj', da.get_all_relaxed_candidates())
write('current_population.traj', population.get_current_population())
def test_basic_example_main_run(seed, testdir):
# set up the random number generator
rng = np.random.RandomState(seed)
# create the surface
slab = fcc111('Au', size=(4, 4, 1), vacuum=10.0, orthogonal=True)
slab.set_constraint(FixAtoms(mask=len(slab) * [True]))
# define the volume in which the adsorbed cluster is optimized
# the volume is defined by a corner position (p0)
# and three spanning vectors (v1, v2, v3)
pos = slab.get_positions()
cell = slab.get_cell()
p0 = np.array([0., 0., max(pos[:, 2]) + 2.])
v1 = cell[0, :] * 0.8
v2 = cell[1, :] * 0.8
v3 = cell[2, :]
v3[2] = 3.
# Define the composition of the atoms to optimize
atom_numbers = 2 * [47] + 2 * [79]
# define the closest distance two atoms of a given species can be to each other
unique_atom_types = get_all_atom_types(slab, atom_numbers)
blmin = closest_distances_generator(atom_numbers=unique_atom_types,
ratio_of_covalent_radii=0.7)
# create the starting population
sg = StartGenerator(slab=slab,
blocks=atom_numbers,
blmin=blmin,
box_to_place_in=[p0, [v1, v2, v3]],
rng=rng)
# generate the starting population
population_size = 5
starting_population = [sg.get_new_candidate() for i in range(population_size)]
# from ase.visualize import view # uncomment these lines
# view(starting_population) # to see the starting population
# create the database to store information in
d = PrepareDB(db_file_name=db_file,
simulation_cell=slab,
stoichiometry=atom_numbers)
for a in starting_population:
d.add_unrelaxed_candidate(a)
# XXXXXXXXXX This should be the beginning of a new test,
# but we are using some resources from the precious part.
# Maybe refactor those things as (module-level?) fixtures.
# Change the following three parameters to suit your needs
population_size = 5
mutation_probability = 0.3
n_to_test = 5
# Initialize the different components of the GA
da = DataConnection('gadb.db')
atom_numbers_to_optimize = da.get_atom_numbers_to_optimize()
n_to_optimize = len(atom_numbers_to_optimize)
slab = da.get_slab()
all_atom_types = get_all_atom_types(slab, atom_numbers_to_optimize)
blmin = closest_distances_generator(all_atom_types,
ratio_of_covalent_radii=0.7)
comp = InteratomicDistanceComparator(n_top=n_to_optimize,
pair_cor_cum_diff=0.015,
pair_cor_max=0.7,
dE=0.02,
mic=False)
pairing = CutAndSplicePairing(slab, n_to_optimize, blmin, rng=rng)
mutations = OperationSelector([1., 1., 1.],
[MirrorMutation(blmin, n_to_optimize, rng=rng),
RattleMutation(blmin, n_to_optimize, rng=rng),
PermutationMutation(n_to_optimize, rng=rng)],
rng=rng)
# Relax all unrelaxed structures (e.g. the starting population)
while da.get_number_of_unrelaxed_candidates() > 0:
a = da.get_an_unrelaxed_candidate()
a.calc = EMT()
print('Relaxing starting candidate {0}'.format(a.info['confid']))
dyn = BFGS(a, trajectory=None, logfile=None)
dyn.run(fmax=0.05, steps=100)
set_raw_score(a, -a.get_potential_energy())
da.add_relaxed_step(a)
# create the population
population = Population(data_connection=da,
population_size=population_size,
comparator=comp,
rng=rng)
# test n_to_test new candidates
for i in range(n_to_test):
print('Now starting configuration number {0}'.format(i))
a1, a2 = population.get_two_candidates()
a3, desc = pairing.get_new_individual([a1, a2])
if a3 is None:
continue
da.add_unrelaxed_candidate(a3, description=desc)
# Check if we want to do a mutation
if rng.rand() < mutation_probability:
a3_mut, desc = mutations.get_new_individual([a3])
if a3_mut is not None:
da.add_unrelaxed_step(a3_mut, desc)
a3 = a3_mut
# Relax the new candidate
a3.calc = EMT()
dyn = BFGS(a3, trajectory=None, logfile=None)
dyn.run(fmax=0.05, steps=100)
set_raw_score(a3, -a3.get_potential_energy())
da.add_relaxed_step(a3)
population.update()
write('all_candidates.traj', da.get_all_relaxed_candidates())
def construct_init_parent(self, ads_cell, ads_pos):
""" construct the initial set of parents """
self.ads_cell = ads_cell
self.ads_pos = ads_pos
Ads_vol = ads_cell[0] * ads_cell[1] * ads_cell[2]
Ads_cell = [[ads_cell[0], 0, 0], [0, ads_cell[1], 0],
[0, 0, ads_cell[2]]]
if self.n_ads == 1:
Atom_Num = self.Ads.get_atomic_numbers(
) # get atomic numbers of your adsorbate
if self.n_ads == 2:
TEMP_for_num = self.Ads[0] + self.Ads[1]
Atom_Num = TEMP_for_num.get_atomic_numbers()
#Atom_Num.append(self.Ads[1].get_atomic_numbers())
unique_atom_types = get_all_atom_types(
self.FW, Atom_Num) # get atomic numbers of your system
cd = closest_distances_generator(
atom_numbers=unique_atom_types, ratio_of_covalent_radii=0.7
) # Generate a dictionary of closest distances
pop = self.pop_size
if self.n_ads == 1:
sg = StartGenerator(
[(self.Ads, self.n_ads)], # Generator Parameters
cd,
Ads_vol,
cell=Ads_cell)
starting_population = [sg.get_new_candidate() for i in range(pop)]
for i in range(pop):
TEMPMOL = self.FW + starting_population[
i] # Add the adsorbates to the frame work
self.Start_Set.append(TEMPMOL)
num = len(self.Ads)
if self.n_ads == 2:
sg = StartGenerator([(self.Ads[0], 1), (self.Ads[1], 1)],
cd,
Ads_vol,
cell=Ads_cell)
starting_population = [sg.get_new_candidate() for i in range(pop)]
for i in range(pop):
TEMPMOL = self.FW + starting_population[i]
self.Start_Set.append(TEMPMOL)
num = len(self.Ads[0]) + len(self.Ads[1])
Cent_Pos = self.ads_pos
#num = len(self.Ads)*self.n_ads
Fin_atoms = np.linspace(0, num - 1, num)
for i in range(pop):
for j in Fin_atoms:
Coord = self.Start_Set[i].get_positions()[-(
int(j) + 1
)] + Cent_Pos # Move the corner of the adsorbate cell to p.o.i.
self.Start_Set[i][-(int(j) + 1)].x = Coord[0] - Ads_cell[0][
0] / 2 # Then you have to fudge the box so its centered
self.Start_Set[i][-(int(j) + 1)].y = Coord[
1] - Ads_cell[1][1] / 2 # around the p.o.i.
self.Start_Set[i][-(int(j) +
1)].z = Coord[2] - Ads_cell[2][2] / 2
self.Start_Set[i].wrap()
