a1 = sg.get_new_candidate()
a1.info['confid'] = 1
a2 = sg.get_new_candidate()
a2.info['confid'] = 2
# Define and test genetic operators
pairing = CutAndSplicePairing(blmin,
p1=1.,
p2=0.,
minfrac=0.15,
cellbounds=cellbounds,
use_tags=True)
a3, desc = pairing.get_new_individual([a1, a2])
cell = a3.get_cell()
assert cellbounds.is_within_bounds(cell)
assert not atoms_too_close(a3, blmin, use_tags=True)
n_top = len(a1)
strainmut = StrainMutation(blmin,
stddev=0.7,
cellbounds=cellbounds,
use_tags=True)
softmut = SoftMutation(blmin,
bounds=[2., 5.],
used_modes_file=None,
use_tags=True)
rotmut = RotationalMutation(blmin, fraction=0.3, min_angle=0.5 * np.pi)
rattlemut = RattleMutation(blmin,
n_top,
rattle_prop=0.3,
def relax_one(t, kptdensity=3.5):
cellbounds = CellBounds(
bounds={
'phi': [0.1 * 180., 0.9 * 180.],
'chi': [0.1 * 180., 0.9 * 180.],
'psi': [0.1 * 180., 0.9 * 180.],
'a': [1.5, 20],
'b': [1.5, 20],
'c': [1.5, 20]
})
if not cellbounds.is_within_bounds(t.get_cell()):
print('Candidate outside cellbounds -- skipping')
finalize(t, energy=1e9, forces=None, stress=None)
return t
pos = t.get_positions()
numbers = list(set(t.get_atomic_numbers()))
blmin = closest_distances_generator(numbers, 0.5)
t = push_apart(t, blmin, variable_cell=True)
print('Starting relaxation', flush=True)
clock = time()
t.wrap()
calc = DftbPlusCalculator(t,
kpts=0.66 * kptdensity,
use_spline=True,
read_chg=True,
maximum_angular_momenta={'C': 1})
try:
t = relax_precon(t,
calc,
fmax=2e-1,
smax=1e-2,
variable_cell=True,
optimizer='LBFGS',
a_min=1e-4,
cellbounds=cellbounds,
logfile='opt_first.log',
trajfile='opt_first.traj')
except (IOError, TypeError, RuntimeError, UnboundLocalError) as err:
# SCC or geometry optimization convergence problem
print(err)
del t.constraints
t.wrap()
calc = DftbPlusCalculator(t,
kpts=kptdensity,
use_spline=True,
read_chg=True,
maximum_angular_momenta={'C': 1})
try:
t = relax_precon(t,
calc,
fmax=1e-1,
smax=5e-3,
variable_cell=True,
optimizer='LBFGS',
a_min=1e-4,
cellbounds=cellbounds,
logfile='opt.log',
trajfile='opt.traj')
except (IOError, TypeError, RuntimeError, UnboundLocalError) as err:
# SCC or geometry optimization convergence problem
print(err)
try:
t = read('opt.traj@-1')
energy = t.get_potential_energy()
forces = t.get_forces()
stress = t.get_stress()
except (FileNotFoundError, UnknownFileTypeError) as err:
print(err)
energy, forces, stress = (1e9, None, None)
finalize(t, energy=energy, forces=forces, stress=stress)
print('Relaxing took %.3f seconds.' % (time() - clock), flush=True)
os.system('mv opt_first.traj prev_first.traj')
os.system('mv opt_first.log prev_first.log')
os.system('mv opt.log prev.log')
os.system('mv opt.traj prev.traj')
penalize(t)
return t
def test_bulk_operators():
h2 = Atoms('H2', positions=[[0, 0, 0], [0, 0, 0.75]])
blocks = [('H', 4), ('H2O', 3), (h2, 2)] # the building blocks
volume = 40. * sum([x[1] for x in blocks]) # cell volume in angstrom^3
splits = {(2,): 1, (1,): 1} # cell splitting scheme
stoichiometry = []
for block, count in blocks:
if type(block) == str:
stoichiometry += list(Atoms(block).numbers) * count
else:
stoichiometry += list(block.numbers) * count
atom_numbers = list(set(stoichiometry))
blmin = closest_distances_generator(atom_numbers=atom_numbers,
ratio_of_covalent_radii=1.3)
cellbounds = CellBounds(bounds={'phi': [30, 150], 'chi': [30, 150],
'psi': [30, 150], 'a': [3, 50],
'b': [3, 50], 'c': [3, 50]})
sg = StartGenerator(blocks, blmin, volume, cellbounds=cellbounds,
splits=splits)
# Generate 2 candidates
a1 = sg.get_new_candidate()
a1.info['confid'] = 1
a2 = sg.get_new_candidate()
a2.info['confid'] = 2
# Define and test genetic operators
pairing = CutAndSplicePairing(blmin, p1=1., p2=0., minfrac=0.15,
cellbounds=cellbounds, use_tags=True)
a3, desc = pairing.get_new_individual([a1, a2])
cell = a3.get_cell()
assert cellbounds.is_within_bounds(cell)
assert not atoms_too_close(a3, blmin, use_tags=True)
n_top = len(a1)
strainmut = StrainMutation(blmin, stddev=0.7, cellbounds=cellbounds,
use_tags=True)
softmut = SoftMutation(blmin, bounds=[2., 5.], used_modes_file=None,
use_tags=True)
rotmut = RotationalMutation(blmin, fraction=0.3, min_angle=0.5 * np.pi)
rattlemut = RattleMutation(blmin, n_top, rattle_prop=0.3, rattle_strength=0.5,
use_tags=True, test_dist_to_slab=False)
rattlerotmut = RattleRotationalMutation(rattlemut, rotmut)
permut = PermutationMutation(n_top, probability=0.33, test_dist_to_slab=False,
use_tags=True, blmin=blmin)
combmut = CombinationMutation(rattlemut, rotmut, verbose=True)
mutations = [strainmut, softmut, rotmut,
rattlemut, rattlerotmut, permut, combmut]
for i, mut in enumerate(mutations):
a = [a1, a2][i % 2]
a3 = None
while a3 is None:
a3, desc = mut.get_new_individual([a])
cell = a3.get_cell()
assert cellbounds.is_within_bounds(cell)
assert np.all(a3.numbers == a.numbers)
assert not atoms_too_close(a3, blmin, use_tags=True)
modes_file = 'modes.txt'
softmut_with = SoftMutation(blmin, bounds=[2., 5.], use_tags=True,
used_modes_file=modes_file)
no_muts = 3
for _ in range(no_muts):
softmut_with.get_new_individual([a1])
softmut_with.read_used_modes(modes_file)
assert len(list(softmut_with.used_modes.values())[0]) == no_muts
os.remove(modes_file)
comparator = OFPComparator(recalculate=True)
gold = bulk('Au') * (2, 2, 2)
assert comparator.looks_like(gold, gold)
# This move should not exceed the default threshold
gc = gold.copy()
gc[0].x += .1
assert comparator.looks_like(gold, gc)
# An additional step will exceed the threshold
gc[0].x += .2
assert not comparator.looks_like(gold, gc)
def relax_one(t, kptdensity=3.5):
cellbounds = CellBounds(bounds={'phi': [0.1 * 180., 0.9 * 180.],
'chi': [0.1 * 180., 0.9 * 180.],
'psi': [0.1 * 180., 0.9 * 180.],
'a': [1.5, 20], 'b': [1.5, 20],
'c':[1.5, 20]})
if not cellbounds.is_within_bounds(t.get_cell()):
print('Candidate outside cellbounds -- skipping')
finalize(t, energy=1e9, forces=None, stress=None)
return t
tags = t.get_tags()
pos = t.get_positions()
pairs = []
for tag in list(set(tags)):
indices = list(np.where(tags == tag)[0])
if len(indices) == 2:
pairs.append(indices)
c = FixBondLengths(pairs)
t.set_constraint(c)
blmin = {(1, 1): 1.8, (1, 8): 0.9, (1, 46): 1.8, (8, 8): 2.0,
(8, 46): 1.5, (46, 46): 1.5}
t = push_apart(t, blmin, variable_cell=True)
del t.constraints
oh_bondlength = 0.97907
for (o_atom, h_atom) in pairs:
vec = t.get_distance(o_atom, h_atom, mic=True, vector=True)
pos[h_atom] = pos[o_atom] + vec * oh_bondlength / np.linalg.norm(vec)
t.set_positions(pos)
print('Starting relaxation', flush=True)
clock = time()
t.wrap()
calc = DftbPlusCalculator(t, kpts=0.66*kptdensity,
use_spline=True, read_chg=True,
maximum_angular_momenta={'Pd': 2, 'H': 0, 'O': 1})
try:
t = relax_precon(t, calc, fmax=2e-1, smax=1e-2, variable_cell=True,
optimizer='LBFGS', a_min=1e-4, cellbounds=cellbounds,
fix_bond_lengths_pairs=pairs, logfile='opt_first.log',
trajfile='opt_first.traj')
except (IOError, TypeError, RuntimeError, UnboundLocalError) as err:
# SCC or geometry optimization convergence problem
print(err)
if isinstance(t, Filter):
t = t.atoms
del t.constraints
t.wrap()
calc = DftbPlusCalculator(t, kpts=kptdensity,
use_spline=True, read_chg=True,
maximum_angular_momenta={'Pd': 2, 'H': 0, 'O': 1})
try:
t = relax_precon(t, calc, fmax=1e-1, smax=5e-3, variable_cell=True,
optimizer='LBFGS', a_min=1e-4, cellbounds=cellbounds,
fix_bond_lengths_pairs=pairs, logfile='opt.log',
trajfile='opt.traj')
except (IOError, TypeError, RuntimeError, UnboundLocalError) as err:
# SCC or geometry optimization convergence problem
print(err)
try:
t = read('opt.traj@-1')
energy = t.get_potential_energy()
forces = t.get_forces()
stress = t.get_stress()
except (FileNotFoundError, UnknownFileTypeError) as err:
print(err)
energy, forces, stress = (1e9, None, None)
if isinstance(t, Filter):
t = t.atoms
finalize(t, energy=energy, forces=forces, stress=stress)
print('Relaxing took %.3f seconds.' % (time() - clock), flush=True)
os.system('mv opt_first.traj prev_first.traj')
os.system('mv opt_first.log prev_first.log')
os.system('mv opt.log prev.log')
os.system('mv opt.traj prev.traj')
penalize(t)
return t
def relax_one(t, kptdensity=1.5):
cellbounds = CellBounds(
bounds={
'phi': [0.1 * 180., 0.9 * 180.],
'chi': [0.1 * 180., 0.9 * 180.],
'psi': [0.1 * 180., 0.9 * 180.],
'a': [1.5, 20],
'b': [1.5, 20],
'c': [1.5, 20]
})
if not cellbounds.is_within_bounds(t.get_cell()):
print('Candidate outside cellbounds -- skipping')
finalize(t, energy=1e9, forces=None, stress=None)
return t
pos = t.get_positions()
numbers = list(set(t.get_atomic_numbers()))
blmin = closest_distances_generator(numbers, 0.5)
t = push_apart(t, blmin, variable_cell=True)
print('Starting relaxation', flush=True)
clock = time()
t.wrap()
calc = DftbPlusCalc(t,
kpts=0.66 * kptdensity,
use_spline=True,
read_chg=True)
try:
t = relax_precon(t,
calc,
fmax=5e-1,
smax=5e-2,
variable_cell=True,
optimizer='LBFGS',
a_min=1e-4,
cellbounds=cellbounds,
logfile='opt_first.log',
trajfile='opt_first.traj')
except IOError as err:
# probably convergence problem
print(err.message)
except TypeError as err:
if 'Cannot cast array data' in err.message:
# Rare precon failure
print(err.message)
else:
raise
except RuntimeError as err:
print(err.message)
del t.constraints
t.wrap()
calc = DftbPlusCalc(t, kpts=kptdensity, use_spline=True, read_chg=True)
try:
t = relax_precon(t,
calc,
fmax=5e-1,
smax=5e-2,
variable_cell=True,
optimizer='LBFGS',
a_min=1e-4,
cellbounds=cellbounds,
logfile='opt.log',
trajfile='opt.traj')
except (IOError, TypeError, RuntimeError) as err:
# probably convergence problem
print(err.message)
if isinstance(err, TypeError):
if 'Cannot cast array data' not in err.message:
raise
elif isinstance(err, RuntimeError):
if 'dftb_my in . returned an error:' not in err.message:
raise
try:
t = read('opt.traj@-1')
energy = t.get_potential_energy()
forces = t.get_forces()
stress = t.get_stress()
except UnknownFileTypeError as err:
print(err.message)
energy, forces, stress = (1e9, None, None)
finalize(t, energy=energy, forces=forces, stress=stress)
print('Relaxing took %.3f seconds.' % (time() - clock), flush=True)
os.system('mv opt_first.traj prev_first.traj')
os.system('mv opt_first.log prev_first.log')
os.system('mv opt.log prev.log')
os.system('mv opt.traj prev.traj')
penalize(t)
return t
# after every mutation, listing which modes have been used so far
# for each structure in the database. The mode indices start at 3
# as the three lowest frequency modes are translational modes.
# Set up the relative probabilities for the different operators
operators = OperationSelector([4., 3., 3.], [pairing, softmut, strainmut])
# Relax the initial candidates
while da.get_number_of_unrelaxed_candidates() > 0:
a = da.get_an_unrelaxed_candidate()
relax(a, cellbounds=cellbounds)
da.add_relaxed_step(a)
cell = a.get_cell()
if not cellbounds.is_within_bounds(cell):
da.kill_candidate(a.info['confid'])
# Initialize the population
population_size = 20
population = Population(data_connection=da,
population_size=population_size,
comparator=comp,
logfile='log.txt',
use_extinct=True)
# Update the scaling volume used in some operators
# based on a number of the best candidates
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)