def symmetrized_optimisation(at_init, filter):
rng = np.random.RandomState(1)
at = at_init.copy()
at.calc = NoisyLennardJones(rng=rng)
at_cell = filter(at)
print("Initial Energy", at.get_potential_energy(), at.get_volume())
with PreconLBFGS(at_cell, precon=None) as dyn:
dyn.run(steps=300, fmax=0.001)
print("n_steps", dyn.get_number_of_steps())
print("Final Energy", at.get_potential_energy(), at.get_volume())
print("Final forces\n", at.get_forces())
print("Final stress\n", at.get_stress())
print("initial symmetry at 1e-6")
di = check_symmetry(at_init, 1.0e-6, verbose=True)
print("final symmetry at 1e-6")
df = check_symmetry(at, 1.0e-6, verbose=True)
return di, df
def relax_config(atoms,
calculator,
relax_pos,
relax_cell,
tol=1e-3,
method='lbfgs',
max_steps=200,
traj_file=None,
constant_volume=False,
refine_symmetry_tol=None,
keep_symmetry=False,
strain_mask=None,
config_label=None,
from_base_model=False,
save_config=False,
fix_cell_dependence=False,
applied_P=0.0,
**kwargs):
# get from base model if requested
#import model
if from_base_model:
if config_label is None:
raise ValueError(
'from_base_model is set but no config_label provided')
try:
base_run_file = os.path.join(
'..', base_run_root,
base_run_root + '-' + config_label + '-relaxed.xyz')
atoms_in = read(base_run_file, format='extxyz')
# set positions from atoms_in rescaling to match current cell
saved_cell = atoms.get_cell().copy()
atoms.set_cell(atoms_in.get_cell())
atoms.set_positions(atoms_in.get_positions())
atoms.set_cell(saved_cell, scale_atoms=True)
print("relax_config read config from ", base_run_file)
except:
try:
print("relax_config failed to read base run config from ",
base_run_root + '-' + config_label + '-relaxed.xyz')
except:
print("relax_config failed to determined base_run_root")
print("relax_config symmetry before refinement at default tol 1.0e-6")
check_symmetry(atoms, 1.0e-6, verbose=True)
if refine_symmetry_tol is not None:
refine_symmetry(atoms, refine_symmetry_tol)
print("relax_config symmetry after refinement")
check_symmetry(atoms, refine_symmetry_tol, verbose=True)
if keep_symmetry:
print("relax_config trying to maintain symmetry")
atoms.set_constraint(FixSymmetry(atoms))
atoms.set_calculator(calculator)
# if needed, fix cell dependence before running
# if fix_cell_dependence and hasattr(model, "fix_cell_dependence"):
# model.fix_cell_dependence(atoms)
if method == 'lbfgs' or method == 'sd2':
if 'move_mask' in atoms.arrays:
atoms.set_constraint(
FixAtoms(np.where(atoms.arrays['move_mask'] == 0)[0]))
if relax_cell:
atoms_cell = ExpCellFilter(atoms,
mask=strain_mask,
constant_volume=constant_volume,
scalar_pressure=applied_P * GPa)
else:
atoms_cell = atoms
atoms.info["n_minim_iter"] = 0
if method == 'sd2':
(traj,
run_stat) = sd2_run("", atoms_cell, tol,
lambda i: sd2_converged(i, atoms_cell, tol),
max_steps)
#if traj_file is not None:
#write(traj_file, traj)
else:
# precon="Exp" specified to resolve an error with the lbfgs not optimising
opt = PreconLBFGS(atoms_cell, use_armijo=False, **kwargs)
if traj_file is not None:
traj = open(traj_file, "w")
def write_trajectory():
if "n_minim_iter" in atoms.info:
atoms.info["n_minim_iter"] += 1
write(traj, atoms, format='extxyz')
#opt.attach(write_trajectory)
elif method == 'cg_n':
raise ValueError(
'minim method cg_n not supported in new python3 quippy')
# if strain_mask is not None:
# raise(Exception("strain_mask not supported with method='cg_n'"))
# atoms.info['Minim_Constant_Volume'] = constant_volume
# opt = Minim(atoms, relax_positions=relax_pos, relax_cell=relax_cell, method='cg_n')
else:
raise ValueError('unknown method %s!' % method)
if method != 'sd2':
opt.run(tol, max_steps)
if refine_symmetry_tol is not None:
print("symmetry at end of relaxation at desired tol")
check_symmetry(atoms, refine_symmetry_tol, verbose=True)
print("symmetry at end of relaxation at default tol 1e-6")
check_symmetry(atoms, 1.0e-6, verbose=True)
# in case we had a trajectory saved
try:
traj.close()
except:
pass
if save_config:
if config_label is None:
raise ValueError('save_config is set but no config_label provided')
#write('-'+config_label+'-relaxed.xyz', atoms, format='extxyz')
if keep_symmetry:
for (i_c, c) in enumerate(atoms.constraints):
if isinstance(c, FixSymmetry):
del atoms.constraints[i_c]
break
# undo fix cell dependence
# if fix_cell_dependence and hasattr(model, "fix_cell_dependence"):
# sys.stderr.write("WARNING: relax_config undoing fix_cell_dependence, whether or not it was set before it started\n")
# model.fix_cell_dependence()
return atoms
dyn.run(fmax=0.001)
print("Final Energy", atoms_unsym.get_potential_energy())
# Now we repeat the optimisation with the symmetrization constraint in place
atoms_sym = atoms_init.copy()
atoms_sym.calc = LennardJones()
atoms_sym.set_constraint(FixSymmetry(atoms_sym))
ucf_sym = UnitCellFilter(atoms_sym)
dyn = BFGS(ucf_sym)
print("Initial Energy", atoms_sym.get_potential_energy())
dyn.run(fmax=0.001)
print("Final Energy", atoms_sym.get_potential_energy())
print("position difference", np.linalg.norm(atoms_unsym.get_positions() -
atoms_sym.get_positions()))
# We print out the initial symmetry groups at two different precision levels
print("initial symmetry at precision 1e-6")
check_symmetry(atoms_init, 1.0e-6, verbose=True)
print("initial symmetry at precision 1e-8")
check_symmetry(atoms_init, 1.0e-8, verbose=True)
# Printing the final symmetries shows that
# the "unsym" case relaxes to a lower energy fcc structure
# with a change in spacegroup, while the "sym" case stays as bcc
print("unsym symmetry after relaxation")
d_unsym = check_symmetry(atoms_unsym, verbose=True)
print("sym symmetry after relaxation")
d_sym = check_symmetry(atoms_sym, verbose=True)