def relax_defect_cell(self, ats, output_name='defect_cell_relaxed.xyz', force_tol=0.0001, relax_cell=False): """ Accepts atoms object with an attached calculator.Minimize forces. Args: ats (:obj:`Atoms`): Atoms with defect to relax. output_name (str, optional): Filename to print relaxed atoms structure to. force_tol (float, optional): Force tolerance to stop relaxation. relax_cell (bool, optional): Relax lattice parameters. Returns: :class:`Atoms`: A relaxed Atoms object. """ from ase.optimize import FIRE if relax_cell: strain_mask = [1, 1, 1, 0, 0, 0] ucf = UnitCellFilter(ats, strain_mask) opt = FIRE(ucf) else: strain_mask = [0, 0, 0, 0, 0, 0] ucf = UnitCellFilter(ats, strain_mask) opt = FIRE(ucf) opt.run(fmax=force_tol) ats.write(output_name) return ats
def test_direct_evaluation(self): a = FaceCenteredCubic('Au', size=[2,2,2]) a.rattle(0.1) calc = EAM('Au-Grochola-JCP05.eam.alloy') a.set_calculator(calc) f = a.get_forces() calc2 = EAM('Au-Grochola-JCP05.eam.alloy') i_n, j_n, dr_nc, abs_dr_n = neighbour_list('ijDd', a, cutoff=calc2.cutoff) epot, virial, f2 = calc2.energy_virial_and_forces(a.numbers, i_n, j_n, dr_nc, abs_dr_n) self.assertArrayAlmostEqual(f, f2) a = FaceCenteredCubic('Cu', size=[2,2,2]) calc = EAM('CuAg.eam.alloy') a.set_calculator(calc) FIRE(StrainFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) e_Cu = a.get_potential_energy()/len(a) a = FaceCenteredCubic('Ag', size=[2,2,2]) a.set_calculator(calc) FIRE(StrainFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) e_Ag = a.get_potential_energy()/len(a) self.assertTrue(abs(e_Ag+2.85)<1e-6) a = L1_2(['Ag', 'Cu'], size=[2,2,2], latticeconstant=4.0) a.set_calculator(calc) FIRE(UnitCellFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) e = a.get_potential_energy() syms = np.array(a.get_chemical_symbols()) self.assertTrue(abs((e-(syms=='Cu').sum()*e_Cu- (syms=='Ag').sum()*e_Ag)/len(a)-0.096)<0.0005) a = B1(['Ag', 'Cu'], size=[2,2,2], latticeconstant=4.0) a.set_calculator(calc) FIRE(UnitCellFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) e = a.get_potential_energy() syms = np.array(a.get_chemical_symbols()) self.assertTrue(abs((e-(syms=='Cu').sum()*e_Cu- (syms=='Ag').sum()*e_Ag)/len(a)-0.516)<0.0005) a = B2(['Ag', 'Cu'], size=[2,2,2], latticeconstant=4.0) a.set_calculator(calc) FIRE(UnitCellFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) e = a.get_potential_energy() syms = np.array(a.get_chemical_symbols()) self.assertTrue(abs((e-(syms=='Cu').sum()*e_Cu- (syms=='Ag').sum()*e_Ag)/len(a)-0.177)<0.0003) a = L1_2(['Cu', 'Ag'], size=[2,2,2], latticeconstant=4.0) a.set_calculator(calc) FIRE(UnitCellFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) e = a.get_potential_energy() syms = np.array(a.get_chemical_symbols()) self.assertTrue(abs((e-(syms=='Cu').sum()*e_Cu- (syms=='Ag').sum()*e_Ag)/len(a)-0.083)<0.0005)
def test_CuAg(self): a = FaceCenteredCubic('Cu', size=[2, 2, 2]) calc = EAM('CuAg.eam.alloy') a.set_calculator(calc) FIRE(StrainFilter(a, mask=[1, 1, 1, 0, 0, 0]), logfile=None).run(fmax=0.001) e_Cu = a.get_potential_energy() / len(a) a = FaceCenteredCubic('Ag', size=[2, 2, 2]) a.set_calculator(calc) FIRE(StrainFilter(a, mask=[1, 1, 1, 0, 0, 0]), logfile=None).run(fmax=0.001) e_Ag = a.get_potential_energy() / len(a) self.assertTrue(abs(e_Ag + 2.85) < 1e-6) a = L1_2(['Ag', 'Cu'], size=[2, 2, 2], latticeconstant=4.0) a.set_calculator(calc) FIRE(UnitCellFilter(a, mask=[1, 1, 1, 0, 0, 0]), logfile=None).run(fmax=0.001) e = a.get_potential_energy() syms = np.array(a.get_chemical_symbols()) self.assertTrue( abs((e - (syms == 'Cu').sum() * e_Cu - (syms == 'Ag').sum() * e_Ag) / len(a) - 0.096) < 0.0005) a = B1(['Ag', 'Cu'], size=[2, 2, 2], latticeconstant=4.0) a.set_calculator(calc) FIRE(UnitCellFilter(a, mask=[1, 1, 1, 0, 0, 0]), logfile=None).run(fmax=0.001) e = a.get_potential_energy() syms = np.array(a.get_chemical_symbols()) self.assertTrue( abs((e - (syms == 'Cu').sum() * e_Cu - (syms == 'Ag').sum() * e_Ag) / len(a) - 0.516) < 0.0005) a = B2(['Ag', 'Cu'], size=[2, 2, 2], latticeconstant=4.0) a.set_calculator(calc) FIRE(UnitCellFilter(a, mask=[1, 1, 1, 0, 0, 0]), logfile=None).run(fmax=0.001) e = a.get_potential_energy() syms = np.array(a.get_chemical_symbols()) self.assertTrue( abs((e - (syms == 'Cu').sum() * e_Cu - (syms == 'Ag').sum() * e_Ag) / len(a) - 0.177) < 0.0003) a = L1_2(['Cu', 'Ag'], size=[2, 2, 2], latticeconstant=4.0) a.set_calculator(calc) FIRE(UnitCellFilter(a, mask=[1, 1, 1, 0, 0, 0]), logfile=None).run(fmax=0.001) e = a.get_potential_energy() syms = np.array(a.get_chemical_symbols()) self.assertTrue( abs((e - (syms == 'Cu').sum() * e_Cu - (syms == 'Ag').sum() * e_Ag) / len(a) - 0.083) < 0.0005)
def relax(runID): db = connect(db_name) atoms = db.get_atoms(id=runID) con = sq.connect(db_name) cur = con.cursor() cur.execute("SELECT value FROM text_key_values WHERE id=? AND key='name'", (runID, )) name = cur.fetchone()[0] con.close() calc = gp.GPAW(mode=gp.PW(600), xc="PBE", kpts=(4, 4, 4), nbands="120%", symmetry="off") atoms.set_calculator(calc) precon = Exp(mu=1.0, mu_c=1.0) save_to_db = SaveToDB(db_name, runID, name) logfile = "logfile%d.log" % (runID) traj = "trajectory%d.traj" % (runID) uf = UnitCellFilter(atoms, hydrostatic_strain=True) relaxer = PreconLBFGS(uf, logfile=logfile, use_armijo=True, precon=precon) relaxer.attach(save_to_db, interval=1, atoms=atoms) trajObj = Trajectory(traj, "w", atoms) relaxer.attach(trajObj) relaxer.run(fmax=0.05, smax=0.003)
def test_md(factory): # XXX ugly hack ver = factory.factory.version() if LooseVersion(ver) < '3.8': pytest.skip('No stress tensor until openmx 3.8+') bud = Atoms('CH4', np.array([[0.000000, 0.000000, 0.100000], [0.682793, 0.682793, 0.682793], [-0.682793, -0.682793, 0.68279], [-0.682793, 0.682793, -0.682793], [0.682793, -0.682793, -0.682793]]), cell=[10, 10, 10]) calc = factory.calc( label='ch4', xc='GGA', energy_cutoff=300 * Ry, convergence=1e-4 * Ha, # Use 'C_PBE19' and 'H_PBE19' for version 3.9 definition_of_atomic_species=[['C', 'C5.0-s1p1', 'C_PBE13'], ['H', 'H5.0-s1', 'H_PBE13']], kpts=(1, 1, 1), eigensolver='Band') bud.calc = calc with Trajectory('example.traj', 'w', bud) as traj: ucf = UnitCellFilter(bud, mask=[True, True, False, False, False, False]) dyn = QuasiNewton(ucf) dyn.attach(traj.write) dyn.run(fmax=0.1) bud.get_potential_energy()
def __init__(self, doc, queue, calculator=None): """ Initialise a relaxation with ASE. Parameters: doc (dict): the structure to optimise. queue (mp.Queue): the queue to push the result to. Keyword arguments: calculator (ase.Calculator): the calculator object to use for force/energy computation. Default is LennardJones. """ from copy import deepcopy from matador.utils.viz_utils import doc2ase from ase.constraints import UnitCellFilter if calculator is None: from ase.calculators.lj import LennardJones self.calc = LennardJones() else: self.calc = calculator self.doc = deepcopy(doc) self.atoms = doc2ase(doc) self.atoms.set_calculator(self.calc) self.ucf = UnitCellFilter(self.atoms) self.queue = queue
def test_stress(atoms): cell0 = atoms.get_cell() atoms.set_cell(np.dot( atoms.cell, [[1.02, 0, 0.03], [0, 0.99, -0.02], [0.1, -0.01, 1.03]]), scale_atoms=True) atoms *= (1, 2, 3) cell0 *= np.array([1, 2, 3])[:, np.newaxis] atoms.rattle() # Verify analytical stress tensor against numerical value s_analytical = atoms.get_stress() s_numerical = atoms.calc.calculate_numerical_stress(atoms, 1e-5) s_p_err = 100 * (s_numerical - s_analytical) / s_numerical print("Analytical stress:\n", s_analytical) print("Numerical stress:\n", s_numerical) print("Percent error in stress:\n", s_p_err) assert np.all(abs(s_p_err) < 1e-5) # Minimize unit cell opt = BFGS(UnitCellFilter(atoms)) opt.run(fmax=1e-3) # Verify minimized unit cell using Niggli tensors g_minimized = np.dot(atoms.cell, atoms.cell.T) g_theory = np.dot(cell0, cell0.T) g_p_err = 100 * (g_minimized - g_theory) / g_theory print("Minimized Niggli tensor:\n", g_minimized) print("Theoretical Niggli tensor:\n", g_theory) print("Percent error in Niggli tensor:\n", g_p_err) assert np.all(abs(g_p_err) < 1)
def evaluate(self, imember): entry = self.population.get_entry(imember) pcm_structure = pychemia.Structure.from_dict(entry['structure']) ase_structure = pychemia.external.ase.pychemia2ase(pcm_structure) ase_structure.set_calculator(LennardJones()) dyn = QuasiNewton(ase_structure) dyn.run() ase_structure.set_constraint( FixAtoms(mask=[True for atom in ase_structure])) ucf = UnitCellFilter(ase_structure) qn = QuasiNewton(ucf) qn.run() new_structure = pychemia.external.ase.ase2pychemia(ase_structure) energy = ase_structure.get_potential_energy() forces = ase_structure.get_forces() stress = ase_structure.get_stress() new_properties = { 'energy': float(energy), 'forces': generic_serializer(forces), 'stress': generic_serializer(stress) } self.population.db.update(imember, structure=new_structure, properties=new_properties)
def test_NaCl_minimize(): from ase.calculators.lammpsrun import LAMMPS from ase.spacegroup import crystal from ase.data import atomic_numbers, atomic_masses from ase.optimize import QuasiNewton from ase.constraints import UnitCellFilter from numpy.testing import assert_allclose a = 6.15 n = 4 nacl = crystal(['Na', 'Cl'], [(0, 0, 0), (0.5, 0.5, 0.5)], spacegroup=225, cellpar=[a, a, a, 90, 90, 90]).repeat((n, n, n)) # Buckingham parameters from # https://physics.stackexchange.com/questions/250018 pair_style = 'buck/coul/long 12.0' pair_coeff = ['1 1 3796.9 0.2603 124.90'] pair_coeff += ['2 2 1227.2 0.3214 124.90'] pair_coeff += ['1 2 4117.9 0.3048 0.0'] masses = [ '1 {}'.format(atomic_masses[atomic_numbers['Na']]), '2 {}'.format(atomic_masses[atomic_numbers['Cl']]) ] with LAMMPS( specorder=['Na', 'Cl'], pair_style=pair_style, pair_coeff=pair_coeff, masses=masses, atom_style='charge', kspace_style='pppm 1.0e-5', keep_tmp_files=True, ) as calc: for a in nacl: if a.symbol == 'Na': a.charge = +1. else: a.charge = -1. nacl.set_calculator(calc) assert_allclose(nacl.get_potential_energy(), -1896.216737561538, atol=1e-4, rtol=1e-4) nacl.get_potential_energy() ucf = UnitCellFilter(nacl) dyn = QuasiNewton(ucf, force_consistent=False) dyn.run(fmax=1.0E-2) assert_allclose(nacl.get_potential_energy(), -1897.208861729178, atol=1e-4, rtol=1e-4)
def relax(atoms, name, calc_mag_state): # relax only along xy-axis to opitmize lattice sf = UnitCellFilter(atoms, mask=[1, 1, 0, 0, 0, 0]) opt = BFGS(sf, trajectory='{0}_relaxed.traj'.format(name), logfile='{0}_relaxed.log'.format(name)) opt.run(fmax=0.05) # until forces < 0.05 eV/atom calc.write('relaxed.gpw') #write gpw file for the magnetic relaxations
def test_unitcellfilter(asap3): cu = bulk('Cu') * (6, 6, 6) cu.calc = asap3.EMT() f = UnitCellFilter(cu, [1, 1, 1, 0, 0, 0]) opt = LBFGS(f) t = Trajectory('Cu-fcc.traj', 'w', cu) opt.attach(t) opt.run(5.0)
def relax(fname): atoms = read(fname) calc = gp.GPAW(mode=gp.PW(600),kpts=(4,4,4),xc="PBE") atoms.set_calculator(calc) uf = UnitCellFilter(atoms,hydrostatic_strain=True) relaxer = PreconLBFGS( uf, logfile="logfile.log" ) relaxer.run( fmax=0.025,smax=0.003 ) write( fname, atoms )
def run_dft(): kpt = 16 atoms = bulk("Al",crystalstructure="fcc",a=4.05) calc = gp.GPAW( mode=gp.PW(600), xc="PBE", kpts=(kpt,kpt,kpt), nbands=-50 ) atoms.set_calculator( calc ) relaxer = BFGS( UnitCellFilter(atoms) ) relaxer.run( fmax=0.025 ) energy = atoms.get_potential_energy() print (energy)
def test_CuZr(self): # This is a test for the potential published in: # Mendelev, Sordelet, Kramer, J. Appl. Phys. 102, 043501 (2007) a = FaceCenteredCubic('Cu', size=[2, 2, 2]) calc = EAM('CuZr_mm.eam.fs', kind='eam/fs') a.set_calculator(calc) FIRE(StrainFilter(a, mask=[1, 1, 1, 0, 0, 0]), logfile=None).run(fmax=0.001) a_Cu = a.cell.diagonal().mean() / 2 #print('a_Cu (3.639) = ', a_Cu) self.assertAlmostEqual(a_Cu, 3.639, 3) a = HexagonalClosedPacked('Zr', size=[2, 2, 2]) a.set_calculator(calc) FIRE(StrainFilter(a, mask=[1, 1, 1, 0, 0, 0]), logfile=None).run(fmax=0.001) a, b, c = a.cell / 2 #print('a_Zr (3.220) = ', norm(a), norm(b)) #print('c_Zr (5.215) = ', norm(c)) self.assertAlmostEqual(norm(a), 3.220, 3) self.assertAlmostEqual(norm(b), 3.220, 3) self.assertAlmostEqual(norm(c), 5.215, 3) # CuZr3 a = L1_2(['Cu', 'Zr'], size=[2, 2, 2], latticeconstant=4.0) a.set_calculator(calc) FIRE(UnitCellFilter(a, mask=[1, 1, 1, 0, 0, 0]), logfile=None).run(fmax=0.001) self.assertAlmostEqual(a.cell.diagonal().mean() / 2, 4.324, 3) # Cu3Zr a = L1_2(['Zr', 'Cu'], size=[2, 2, 2], latticeconstant=4.0) a.set_calculator(calc) FIRE(UnitCellFilter(a, mask=[1, 1, 1, 0, 0, 0]), logfile=None).run(fmax=0.001) self.assertAlmostEqual(a.cell.diagonal().mean() / 2, 3.936, 3) # CuZr a = B2(['Zr', 'Cu'], size=[2, 2, 2], latticeconstant=3.3) a.set_calculator(calc) FIRE(UnitCellFilter(a, mask=[1, 1, 1, 0, 0, 0]), logfile=None).run(fmax=0.001) self.assertAlmostEqual(a.cell.diagonal().mean() / 2, 3.237, 3)
def __init__(self, atoms, pairs, bondlengths=None, tolerance=1e-13, maxiter=500, **kwargs): UnitCellFilter.__init__(self, atoms, **kwargs) self.pairs = np.asarray(pairs) self.bondlengths = bondlengths self.tolerance = tolerance self.maxiter = maxiter if self.bondlengths is None: self.bondlengths = np.zeros(len(self.pairs)) for i, ab in enumerate(self.pairs): self.bondlengths[i] = atoms.get_distance(ab[0], ab[1], mic=True)
def _get_optimized_cell(self, structure, potential): atoms = self._get_ase_from_pmg(structure) atoms.set_calculator(potential) try: sf = UnitCellFilter(atoms) dyn = BFGS(sf) dyn.run(fmax=1e-5) sf = StrainFilter(atoms) dyn = BFGS(sf) dyn.run(fmax=1e-5) dyn = BFGS(atoms) dyn.run(fmax=1e-5) sf = UnitCellFilter(atoms) dyn = BFGS(sf) dyn.run(fmax=1e-5) except AttributeError: warnings.warn("No optimization is performed.") return self._get_pmg_from_ase(atoms)
def test_unitcellfilter_hcp(asap3, testdir): cu = bulk('Cu', 'hcp', a=3.6 / 2.0**0.5) cu.cell[1, 0] -= 0.05 cu *= (6, 6, 3) cu.calc = asap3.EMT() print(cu.get_forces()) print(cu.get_stress()) f = UnitCellFilter(cu) opt = MDMin(f, dt=0.01) with Trajectory('Cu-hcp.traj', 'w', cu) as t: opt.attach(t) opt.run(0.2)
def main(runId): db = connect(DB_NAME) row = db.get(id=runId) group = row.group atoms = row.toatoms() niggli_reduce(atoms) calc = EMT() atoms.set_calculator(calc) ucell = UnitCellFilter(atoms) opt = PreconLBFGS(ucell) opt.run(fmax=0.02, smax=0.003) db.write(atoms, group=group, struct_type='relaxed')
def calc_gap(): oraxis = '0,0,1' pot_param = PotentialParameters() ener_per_atom = pot_param.gs_ener_per_atom() selected_grains = GrainBoundary.select().where( GrainBoundary.orientation_axis == oraxis).where( GrainBoundary.boundary_plane != oraxis) f = open('./locenviron/gap_energies.dat', 'a') for gb in selected_grains.order_by(GrainBoundary.angle)[2:]: subgbs = (gb.subgrains.select( GrainBoundary, SubGrainBoundary).where(SubGrainBoundary.potential == 'PotBH.xml').join(GrainBoundary).dicts()) subgbs = [ (16.02 * (subgb['E_gb'] - float(subgb['n_at'] * ener_per_atom['PotBH.xml'])) / (2.0 * subgb['area']), subgb) for subgb in subgbs ] subgbs.sort(key=lambda x: x[0]) try: print subgbs[0][1]['path'] continue target_dir = os.path.join('./grain_boundaries', subgbs[0][1]['path']) struct_file = os.path.join(target_dir, subgbs[0][1]['gbid']) + '_traj.xyz' print struct_file ats = AtomsReader(struct_file)[-1] pot = Potential('IP GAP', param_filename='gp33b.xml') ats.set_calculator(pot) print subgbs[0][1]['n_at'], subgbs[0][1]['area'] strain_mask = [0, 0, 1, 0, 0, 0] ucf = UnitCellFilter(ats, strain_mask) opt = FIRE(ucf) FORCE_TOL = 0.1 opt.run(fmax=FORCE_TOL) gap_en = ats.get_potential_energy() print gap_en print round(gb.angle * (180.0 / 3.14159), 3), round( subgbs[0][0], 3), 16.02 * (gap_en - float( subgbs[0][1]['n_at'] * ener_per_atom['gp33b.xml'])) / ( 2.0 * subgbs[0][1]['area']) print >> f, round(gb.angle * (180.0 / 3.14159), 3), round( subgbs[0][0], 3), 16.02 * (gap_en - float( subgbs[0][1]['n_at'] * ener_per_atom['gp33b.xml'])) / ( 2.0 * subgbs[0][1]['area']) ats.write('./locenviron/{}.xyz'.format(subgbs[0][1]['gbid'])) except IndexError: print '\t', round(gb.angle * (180.0 / 3.14159), 3), subgbs
def test_md(): import numpy as np import unittest from ase.units import Ry, Ha from ase.calculators.openmx import OpenMX from ase.io.trajectory import Trajectory from ase.optimize import QuasiNewton from ase.constraints import UnitCellFilter from ase.calculators.calculator import PropertyNotImplementedError from ase import Atoms """ Only OpenMX 3.8 or higher version pass this test""" bud = Atoms('CH4', np.array([ [0.000000, 0.000000, 0.100000], [0.682793, 0.682793, 0.682793], [-0.682793, -0.682793, 0.68279], [-0.682793, 0.682793, -0.682793], [0.682793, -0.682793, -0.682793]]), cell=[10, 10, 10]) calc = OpenMX( label='ch4', xc='GGA', energy_cutoff=300 * Ry, convergence=1e-4 * Ha, # Use 'C_PBE19' and 'H_PBE19' for version 3.9 definition_of_atomic_species=[['C', 'C5.0-s1p1', 'C_PBE13'], ['H', 'H5.0-s1', 'H_PBE13']], kpts=(4, 4, 4), eigensolver='Band' ) bud.set_calculator(calc) try: bud.get_stress() except PropertyNotImplementedError as err: raise unittest.SkipTest(err) traj = Trajectory('example.traj', 'w', bud) ucf = UnitCellFilter(bud, mask=[True, True, False, False, False, False]) dyn = QuasiNewton(ucf) dyn.attach(traj.write) dyn.run(fmax=0.1) bud.get_potential_energy() # XXX maybe assert something? traj.close()
def test_unitcellfilter(asap3): a = 3.6 b = a / 2 cu = Atoms('Cu', cell=[(0, b, b), (b, 0, b), (b, b, 0)], pbc=1) * (6, 6, 6) cu.calc = asap3.EMT() f = UnitCellFilter(cu, [1, 1, 1, 0, 0, 0]) opt = LBFGS(f) t = Trajectory('Cu-fcc.traj', 'w', cu) opt.attach(t) opt.run(5.0) # HCP: from ase.build import bulk cu = bulk('Cu', 'hcp', a=a / sqrt(2)) cu.cell[1, 0] -= 0.05 cu *= (6, 6, 3) cu.calc = asap3.EMT() print(cu.get_forces()) print(cu.get_stress()) f = UnitCellFilter(cu) opt = MDMin(f, dt=0.01) t = Trajectory('Cu-hcp.traj', 'w', cu) opt.attach(t) opt.run(0.2)
def test_unitcellfilter(): from math import sqrt from ase import Atoms from ase.optimize import LBFGS from ase.constraints import UnitCellFilter from ase.io import Trajectory from ase.optimize.mdmin import MDMin try: from asap3 import EMT except ImportError: pass else: a = 3.6 b = a / 2 cu = Atoms('Cu', cell=[(0, b, b), (b, 0, b), (b, b, 0)], pbc=1) * (6, 6, 6) cu.set_calculator(EMT()) f = UnitCellFilter(cu, [1, 1, 1, 0, 0, 0]) opt = LBFGS(f) t = Trajectory('Cu-fcc.traj', 'w', cu) opt.attach(t) opt.run(5.0) # HCP: from ase.build import bulk cu = bulk('Cu', 'hcp', a=a / sqrt(2)) cu.cell[1, 0] -= 0.05 cu *= (6, 6, 3) cu.set_calculator(EMT()) print(cu.get_forces()) print(cu.get_stress()) f = UnitCellFilter(cu) opt = MDMin(f, dt=0.01) t = Trajectory('Cu-hcp.traj', 'w', cu) opt.attach(t) opt.run(0.2)
def run(self, fmax, smax, smask=None, emin=-np.inf): self.smax = smax self.smask = smask self.emin = emin uf = UnitCellFilter(self.atoms, mask=smask) self.opt = ase.optimize.BFGS(uf, logfile=self._logfile, trajectory=self.trajectory) self.opt.log = self.log self.opt.converged = self.converged self.force_consistent = self.opt.force_consistent self.step0 = self.opt.step self.opt.step = self.step self.opt.run(fmax)
def opt_run(ixsf_path, itraj_path, ixsf_file_name, index): print('%d' % index + ' In directory : %s' % (ixsf_path + ixsf_file_name)) atoms = read(ixsf_path + ixsf_file_name) calc = ANNCalculator(potentials={ "Ga": "Ga.10t-10t.nn", "N": "N.10t-10t.nn" }) atoms.set_calculator(calc) ucf = UnitCellFilter(atoms) opt = BFGS(ucf) traj = Trajectory(itraj_path + 'opt_%i.traj' % index, 'w', atoms) opt.attach(traj, interval=40) opt.run(fmax=0.05)
def optimize(self, atoms, name): args = self.args if args.constrain_tags: tags = [int(t) for t in args.constrain_tags.split(',')] mask = [t in tags for t in atoms.get_tags()] atoms.constraints = FixAtoms(mask=mask) logfile = self.get_filename(name, 'log') if args.maximum_stress: optimizer = LBFGS(UnitCellFilter(atoms), logfile=logfile) fmax = args.maximum_stress else: optimizer = LBFGS(atoms, logfile=logfile) fmax = args.maximum_force trajectory = Trajectory(self.get_filename(name, 'traj'), 'w', atoms) optimizer.attach(trajectory) optimizer.run(fmax=fmax)
def main(runID): db = connect(db_name) atoms = db.get_atoms(id=runID) N = 14 calc = gp.GPAW(mode=gp.PW(500), xc="PBE", kpts=(N, N, N), nbands=-50, symmetry={'do_not_symmetrize_the_density': True}) atoms.set_calculator(calc) precon = Exp(mu=1.0, mu_c=1.0) uf = UnitCellFilter(atoms, hydrostatic_strain=True) logfile = "al3mg2{}.log".format(runID) relaxer = PreconLBFGS(uf, logfile=logfile, use_armijo=True, precon=precon) relaxer.run(fmax=0.025, smax=0.003) energy = atoms.get_potential_energy() del db[db.get(id=runID)] db.write(atoms)
def test_pwscf_calculator(): if not have_ase(): skip("no ASE found, skipping test") elif not have_pwx(): skip("no pw.x found, skipping test") else: pseudo_dir = pj(testdir, prefix, 'pseudo') print(common.backtick("mkdir -pv {p}; cp files/qe_pseudos/*.gz {p}/; \ gunzip {p}/*".format(p=pseudo_dir))) at = get_atoms_with_calc_pwscf(pseudo_dir) print("scf") # trigger calculation here forces = at.get_forces() etot = at.get_potential_energy() stress = at.get_stress(voigt=False) # 3x3 st = io.read_pw_scf(at.calc.label + '.out') assert np.allclose(forces, st.forces) assert np.allclose(etot, st.etot) assert np.allclose(st.stress, -stress * constants.eV_by_Ang3_to_GPa) # files/ase/pw.scf.out.start is a norm-conserving LDA struct, # calculated with pz-vbc.UPF, so the PBE vc-relax will make the cell # a bit bigger print("vc-relax") from ase.optimize import BFGS from ase.constraints import UnitCellFilter opt = BFGS(UnitCellFilter(at)) cell = parse.arr2d_from_txt(""" -1.97281509 0. 1.97281509 0. 1.97281509 1.97281509 -1.97281509 1.97281509 0.""") assert np.allclose(cell, at.get_cell()) opt.run(fmax=0.05) # run only 2 steps cell = parse.arr2d_from_txt(""" -2.01837531 0. 2.01837531 0. 2.01837531 2.01837531 -2.01837531 2.01837531 0""") assert np.allclose(cell, at.get_cell()) # at least 1 backup files must exist: pw.*.0 is the SCF run, backed up # in the first iter of the vc-relax assert os.path.exists(at.calc.infile + '.0')
def test_stress(): # Theoretical infinite-cutoff LJ FCC unit cell parameters vol0 = 4 * 0.91615977036 # theoretical minimum a0 = vol0**(1 / 3) a = bulk('X', 'fcc', a=a0) cell0 = a.get_cell() a.calc = LennardJones() a.set_cell(np.dot(a.cell, [[1.02, 0, 0.03], [0, 0.99, -0.02], [0.1, -0.01, 1.03]]), scale_atoms=True) a *= (1, 2, 3) cell0 *= np.array([1, 2, 3])[:, np.newaxis] a.rattle() # Verify analytical stress tensor against numerical value s_analytical = a.get_stress() s_numerical = a.calc.calculate_numerical_stress(a, 1e-5) s_p_err = 100 * (s_numerical - s_analytical) / s_numerical print("Analytical stress:\n", s_analytical) print("Numerical stress:\n", s_numerical) print("Percent error in stress:\n", s_p_err) assert np.all(abs(s_p_err) < 1e-5) # Minimize unit cell opt = BFGS(UnitCellFilter(a)) opt.run(fmax=1e-3) # Verify minimized unit cell using Niggli tensors g_minimized = np.dot(a.cell, a.cell.T) g_theory = np.dot(cell0, cell0.T) g_p_err = 100 * (g_minimized - g_theory) / g_theory print("Minimized Niggli tensor:\n", g_minimized) print("Theoretical Niggli tensor:\n", g_theory) print("Percent error in Niggli tensor:\n", g_p_err) assert np.all(abs(g_p_err) < 1)
def test_unitcellfilterpressure(): a0 = bulk('Cu', cubic=True) # perturb the atoms s = a0.get_scaled_positions() s[:, 0] *= 0.995 a0.set_scaled_positions(s) # perturb the cell a0.cell[...] += np.random.uniform(-1e-2, 1e-2, size=9).reshape((3, 3)) atoms = a0.copy() atoms.calc = LennardJones() ucf = UnitCellFilter(atoms, scalar_pressure=10.0 * GPa) # test all derivatives f, fn = gradient_test(ucf) assert abs(f - fn).max() < 1e-6 opt = FIRE(ucf) opt.run(1e-3) # check pressure is within 0.1 GPa of target sigma = atoms.get_stress() / GPa pressure = -(sigma[0] + sigma[1] + sigma[2]) / 3.0 assert abs(pressure - 10.0) < 0.1 atoms = a0.copy() atoms.calc = LennardJones() ecf = ExpCellFilter(atoms, scalar_pressure=10.0 * GPa) # test all deritatives f, fn = gradient_test(ecf) assert abs(f - fn).max() < 1e-6 opt = LBFGSLineSearch(ecf) opt.run(1e-3) # check pressure is within 0.1 GPa of target sigma = atoms.get_stress() / GPa pressure = -(sigma[0] + sigma[1] + sigma[2]) / 3.0 assert abs(pressure - 10.0) < 0.1
def test_precon(): cu0 = bulk("Cu") * (2, 2, 2) lj = LennardJones(sigma=cu0.get_distance(0,1)) cu = cu0.copy() cu.set_cell(1.2*cu.get_cell()) cu.calc = lj ucf = UnitCellFilter(cu, constant_volume=True) opt = PreconLBFGS(ucf, precon=Exp(mu=1.0, mu_c=1.0)) opt.run(fmax=1e-3) assert abs(np.linalg.det(cu.cell)/np.linalg.det(cu0.cell) - 1.2**3) < 1e-3 # EcpCellFilter allows relaxing to lower tolerance cu = cu0.copy() cu.set_cell(1.2*cu.get_cell()) cu.calc = lj ecf = ExpCellFilter(cu, constant_volume=True) opt = PreconLBFGS(ecf, precon=Exp(mu=1.0, mu_c=1.0)) opt.run(fmax=1e-3) assert abs(np.linalg.det(cu.cell)/np.linalg.det(cu0.cell) - 1.2**3) < 1e-7