def get_atoms_adsorbate():
# We need the relaxed slab here!
slab = Atoms([
Atom('Cu',
[-1.028468159509163, -0.432387156877267, -0.202086055768265]),
Atom('Cu', [0.333333333333333, 0.333333333333333, -2.146500000000000]),
Atom('Cu',
[1.671531840490805, -0.432387156877287, -0.202086055768242]),
Atom('Cu', [3.033333333333334, 0.333333333333333, -2.146500000000000]),
Atom('Cu',
[4.371531840490810, -0.432387156877236, -0.202086055768261]),
Atom('Cu', [5.733333333333333, 0.333333333333333, -2.146500000000000]),
Atom('Cu',
[7.071531840490944, -0.432387156877258, -0.202086055768294]),
Atom('Cu', [8.433333333333335, 0.333333333333333, -2.146500000000000]),
Atom('Cu', [0.321531840490810, 1.905881433340708, -0.202086055768213]),
Atom('Cu', [1.683333333333333, 2.671601923551318, -2.146500000000000]),
Atom('Cu', [3.021531840490771, 1.905881433340728, -0.202086055768250]),
Atom('Cu', [4.383333333333334, 2.671601923551318, -2.146500000000000]),
Atom('Cu', [5.721531840490857, 1.905881433340735, -0.202086055768267]),
Atom('Cu', [7.083333333333333, 2.671601923551318, -2.146500000000000]),
Atom('Cu', [8.421531840490820, 1.905881433340739, -0.202086055768265]),
Atom('Cu', [9.783333333333335, 2.671601923551318, -2.146500000000000]),
Atom('Cu', [1.671531840490742, 4.244150023558601, -0.202086055768165]),
Atom('Cu', [3.033333333333334, 5.009870513769302, -2.146500000000000]),
Atom('Cu', [4.371531840490840, 4.244150023558694, -0.202086055768265]),
Atom('Cu', [5.733333333333333, 5.009870513769302, -2.146500000000000]),
Atom('Cu', [7.071531840490880, 4.244150023558786, -0.202086055768352]),
Atom('Cu', [8.433333333333335, 5.009870513769302, -2.146500000000000]),
Atom('Cu', [9.771531840491031, 4.244150023558828, -0.202086055768371]),
Atom('Cu',
[11.133333333333335, 5.009870513769302, -2.146500000000000]),
Atom('Cu', [3.021531840490714, 6.582418613776583, -0.202086055768197]),
Atom('Cu', [4.383333333333334, 7.348139103987287, -2.146500000000000]),
Atom('Cu', [5.721531840490814, 6.582418613776629, -0.202086055768203]),
Atom('Cu', [7.083333333333333, 7.348139103987287, -2.146500000000000]),
Atom('Cu', [8.421531840490985, 6.582418613776876, -0.202086055768357]),
Atom('Cu', [9.783333333333335, 7.348139103987287, -2.146500000000000]),
Atom('Cu',
[11.121531840490929, 6.582418613776676, -0.202086055768221]),
Atom('Cu',
[12.483333333333334, 7.348139103987287, -2.146500000000000]),
])
mask = [a.position[2] < -1 for a in slab]
slab.set_constraint(FixAtoms(mask=mask))
a = 2.70
c = 1.59 * a
h = 1.85
d = 1.10
x = slab.positions[0, 2] / (c / 2) * 100
molecule = Atoms('2N', positions=[(0., 0., h), (0., 0., h + d)])
molecule.set_calculator(EMT())
slab.extend(molecule)
return slab
from math import sqrt
from ase_ext import Atoms
from ase_ext.constraints import StrainFilter
from ase_ext.optimize.mdmin import MDMin
from ase_ext.io import PickleTrajectory
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 = StrainFilter(cu, [1, 1, 1, 0, 0, 0])
opt = MDMin(f, dt=0.01)
t = PickleTrajectory('Cu.traj', 'w', cu)
opt.attach(t)
opt.run(0.001)
# HCP:
from ase_ext.lattice.surface import hcp0001
cu = hcp0001('Cu', (1, 1, 2), a=a / sqrt(2))
cu.cell[1, 0] += 0.05
cu *= (6, 6, 3)
cu.set_calculator(EMT())
f = StrainFilter(cu)
opt = MDMin(f, dt=0.01)
t = PickleTrajectory('Cu.traj', 'w', cu)
d = 1.14
co = Atoms('CO', positions=[(0, 0, 0), (0, 0, d)],
pbc=True)
co.center(vacuum=5.)
calc = Vasp(
xc = 'PBE',
prec = 'Low',
algo = 'Fast',
ismear= 0,
sigma = 1.,
lwave = False,
lcharg = False)
co.set_calculator(calc)
en = co.get_potential_energy()
assert abs(en + 14.918933) < 1e-4
# Secondly, check that restart from the previously created VASP output works
calc2 = Vasp(restart=True)
co2 = calc2.get_atoms()
# Need tolerance of 1e-14 because VASP itself changes coordinates
# slightly between reading POSCAR and writing CONTCAR even if no ionic
# steps are made.
assert array_almost_equal(co.positions, co2.positions, 1e-14)
assert en - co2.get_potential_energy() == 0.
assert array_almost_equal(calc.get_stress(co), calc2.get_stress(co2))
print("No Scientific python found. Check your PYTHONPATH")
raise NotAvailable('ScientificPython version 2.8 or greater is required')
if not (os.system('which dacapo.run') == 0):
print(
"No Dacapo Fortran executable (dacapo.run) found. Check your path settings."
)
raise NotAvailable(
'dacapo.run is not installed on this machine or not in the path')
# Now Scientific 2.8 and dacapo.run should both be available
from ase_ext import Atoms, Atom
from ase_ext.calculators.jacapo import Jacapo
atoms = Atoms([Atom('H', [0, 0, 0])], cell=(2, 2, 2))
calc = Jacapo('Jacapo-test.nc',
pw=200,
nbands=2,
kpts=(1, 1, 1),
spinpol=False,
dipole=False,
symmetry=False,
ft=0.01)
atoms.set_calculator(calc)
print(atoms.get_potential_energy())
os.system('rm -f Jacapo-test.nc Jacapo-test.txt')
def read_aims_output(filename, index=-1):
""" Import FHI-aims output files with all data available, i.e. relaxations,
MD information, force information etc etc etc. """
from ase_ext import Atoms, Atom
from ase_ext.calculators.singlepoint import SinglePointCalculator
from ase_ext.units import Ang, fs
molecular_dynamics = False
fd = open(filename, 'r')
cell = []
images = []
n_periodic = -1
f = None
pbc = False
found_aims_calculator = False
v_unit = Ang / (1000.0 * fs)
while True:
line = fd.readline()
if not line:
break
if "List of parameters used to initialize the calculator:" in line:
fd.readline()
calc = read_aims_calculator(fd)
calc.out = filename
found_aims_calculator = True
if "Number of atoms" in line:
inp = line.split()
n_atoms = int(inp[5])
if "| Unit cell:" in line:
if not pbc:
pbc = True
for i in range(3):
inp = fd.readline().split()
cell.append([inp[1], inp[2], inp[3]])
if "Atomic structure:" in line and not molecular_dynamics:
fd.readline()
atoms = Atoms()
for i in range(n_atoms):
inp = fd.readline().split()
atoms.append(Atom(inp[3], (inp[4], inp[5], inp[6])))
if "Complete information for previous time-step:" in line:
molecular_dynamics = True
if "Updated atomic structure:" in line and not molecular_dynamics:
fd.readline()
atoms = Atoms()
velocities = []
for i in range(n_atoms):
inp = fd.readline().split()
atoms.append(Atom(inp[4], (inp[1], inp[2], inp[3])))
if molecular_dynamics:
inp = fd.readline().split()
if "Atomic structure (and velocities)" in line:
fd.readline()
atoms = Atoms()
velocities = []
for i in range(n_atoms):
inp = fd.readline().split()
atoms.append(Atom(inp[4], (inp[1], inp[2], inp[3])))
inp = fd.readline().split()
velocities += [[
float(inp[1]) * v_unit,
float(inp[2]) * v_unit,
float(inp[3]) * v_unit
]]
atoms.set_velocities(velocities)
images.append(atoms)
if "Total atomic forces" in line:
f = []
for i in range(n_atoms):
inp = fd.readline().split()
f.append([float(inp[2]), float(inp[3]), float(inp[4])])
if not found_aims_calculator:
e = images[-1].get_potential_energy()
images[-1].set_calculator(
SinglePointCalculator(e, f, None, None, atoms))
e = None
f = None
if "Total energy corrected" in line:
e = float(line.split()[5])
if pbc:
atoms.set_cell(cell)
atoms.pbc = True
if not found_aims_calculator:
atoms.set_calculator(
SinglePointCalculator(e, None, None, None, atoms))
if not molecular_dynamics:
images.append(atoms)
e = None
if found_aims_calculator:
calc.set_results(images[-1])
images[-1].set_calculator(calc)
fd.close()
if molecular_dynamics:
images = images[1:]
# return requested images, code borrowed from ase_ext.io/trajectory.py
if isinstance(index, int):
return images[index]
else:
step = index.step or 1
if step > 0:
start = index.start or 0
if start < 0:
start += len(images)
stop = index.stop or len(images)
if stop < 0:
stop += len(images)
else:
if index.start is None:
start = len(images) - 1
else:
start = index.start
if start < 0:
start += len(images)
if index.stop is None:
stop = -1
else:
stop = index.stop
if stop < 0:
stop += len(images)
return [images[i] for i in range(start, stop, step)]
from ase_ext import Atom, Atoms
from gpaw import GPAW
a = 4.0
b = a / 2**.5
L = 7.0
al = Atoms([Atom('Al')], cell=(b, b, L), pbc=True)
calc = GPAW(kpts=(4, 4, 1))
al.set_calculator(calc)
al.get_potential_energy()
calc.write('Al100.gpw', 'all')
from ase_ext import Atoms
from ase_ext.calculators.emt import EMT
from ase_ext.md import VelocityVerlet
from ase_ext.io import PickleTrajectory
a = 3.6
b = a / 2
fcc = Atoms('Cu',
positions=[(0, 0, 0)],
cell=[(0, b, b), (b, 0, b), (b, b, 0)],
pbc=1)
fcc *= (2, 1, 1)
fcc.set_calculator(EMT())
fcc.set_momenta([(0.9, 0.0, 0.0), (-0.9, 0, 0)])
md = VelocityVerlet(fcc, dt=0.1)
def f():
print(fcc.get_potential_energy(), fcc.get_total_energy())
md.attach(f)
md.attach(PickleTrajectory('Cu2.traj', 'w', fcc).write, interval=3)
md.run(steps=20)
fcc2 = PickleTrajectory('Cu2.traj', 'r')[-1]
def read_vasp_out(filename='OUTCAR', index=-1):
"""Import OUTCAR type file.
Reads unitcell, atom positions, energies, and forces from the OUTCAR file.
- does not (yet) read any constraints
"""
import os
import numpy as np
from ase_ext.calculators.singlepoint import SinglePointCalculator
from ase_ext import Atoms, Atom
if isinstance(filename, str):
f = open(filename)
else: # Assume it's a file-like object
f = filename
data = f.readlines()
natoms = 0
images = []
atoms = Atoms(pbc=True)
energy = 0
species = []
species_num = []
symbols = []
for n, line in enumerate(data):
if 'POSCAR:' in line:
temp = line.split()
species = temp[1:]
if 'ions per type' in line:
temp = line.split()
for ispecies in range(len(species)):
species_num += [int(temp[ispecies + 4])]
natoms += species_num[-1]
for iatom in range(species_num[-1]):
symbols += [species[ispecies]]
if 'direct lattice vectors' in line:
cell = []
for i in range(3):
temp = data[n + 1 + i].split()
cell += [[float(temp[0]), float(temp[1]), float(temp[2])]]
atoms.set_cell(cell)
if 'FREE ENERGIE OF THE ION-ELECTRON SYSTEM' in line:
energy = float(data[n + 2].split()[4])
if 'POSITION ' in line:
forces = []
for iatom in range(natoms):
temp = data[n + 2 + iatom].split()
atoms += Atom(symbols[iatom],
[float(temp[0]),
float(temp[1]),
float(temp[2])])
forces += [[float(temp[3]), float(temp[4]), float(temp[5])]]
atoms.set_calculator(
SinglePointCalculator(energy, forces, None, None, atoms))
images += [atoms]
atoms = Atoms(pbc=True)
# return requested images, code borrowed from ase_ext.io/trajectory.py
if isinstance(index, int):
return images[index]
else:
step = index.step or 1
if step > 0:
start = index.start or 0
if start < 0:
start += len(images)
stop = index.stop or len(images)
if stop < 0:
stop += len(images)
else:
if index.start is None:
start = len(images) - 1
else:
start = index.start
if start < 0:
start += len(images)
if index.stop is None:
stop = -1
else:
stop = index.stop
if stop < 0:
stop += len(images)
return [images[i] for i in range(start, stop, step)]
import numpy as np
from math import pi, sqrt
from ase_ext import Atoms
from ase_ext.calculators.lj import LennardJones
from ase_ext.optimize.basin import BasinHopping
from ase_ext.io import PickleTrajectory, read
from ase_ext.units import kB
N = 7
R = N**(1. / 3.)
pos = np.random.uniform(-R, R, (N, 3))
s = Atoms('He' + str(N), positions=pos)
s.set_calculator(LennardJones())
ftraj = 'lowest.traj'
traj = PickleTrajectory(ftraj, 'w', s)
bh = BasinHopping(s, temperature=100 * kB, dr=0.5, optimizer_logfile=None)
bh.attach(traj)
bh.run(10)
Emin, smin = bh.get_minimum()
# recalc energy
smin.set_calculator(LennardJones())
E = smin.get_potential_energy()
assert abs(E - Emin) < 1e-15
traj.close()
smim = read(ftraj)
E = smin.get_potential_energy()
assert abs(E - Emin) < 1e-15