def get_constraint(constraint_idx):
"""
Map constraints from QE output to FixAtoms or FixCartesian constraint
"""
if not np.any(constraint_idx):
return None
a = [a for a, c in enumerate(constraint_idx) if np.all(c is not None)]
mask = [[(ic + 1) % 2 for ic in c] for c in constraint_idx
if np.all(c is not None)]
if np.all(np.array(mask)) == 1:
constraint = FixAtoms(a)
else:
constraint = FixCartesian(a, mask)
return constraint
def _read_xyz_frame(lines,
natoms,
properties_parser=key_val_str_to_dict,
nvec=0):
# comment line
line = next(lines).strip()
if nvec > 0:
info = {'comment': line}
else:
info = properties_parser(line) if line else {}
pbc = None
if 'pbc' in info:
pbc = info['pbc']
del info['pbc']
elif 'Lattice' in info:
# default pbc for extxyz file containing Lattice
# is True in all directions
pbc = [True, True, True]
elif nvec > 0:
# cell information given as pseudo-Atoms
pbc = [False, False, False]
cell = None
if 'Lattice' in info:
# NB: ASE cell is transpose of extended XYZ lattice
cell = info['Lattice'].T
del info['Lattice']
elif nvec > 0:
# cell information given as pseudo-Atoms
cell = np.zeros((3, 3))
if 'Properties' not in info:
# Default set of properties is atomic symbols and positions only
info['Properties'] = 'species:S:1:pos:R:3'
properties, names, dtype, convs = parse_properties(info['Properties'])
del info['Properties']
data = []
for ln in range(natoms):
try:
line = next(lines)
except StopIteration:
raise XYZError(
'ase.io.extxyz: Frame has {} atoms, expected {}'.format(
len(data), natoms))
vals = line.split()
row = tuple([conv(val) for conv, val in zip(convs, vals)])
data.append(row)
try:
data = np.array(data, dtype)
except TypeError:
raise XYZError('Badly formatted data '
'or end of file reached before end of frame')
# Read VEC entries if present
if nvec > 0:
for ln in range(nvec):
try:
line = next(lines)
except StopIteration:
raise XYZError(
'ase.io.adfxyz: Frame has {} cell vectors, expected {}'.
format(len(cell), nvec))
entry = line.split()
if not entry[0].startswith('VEC'):
raise XYZError('Expected cell vector, got {}'.format(entry[0]))
try:
n = int(entry[0][3:])
if n != ln + 1:
raise XYZError('Expected VEC{}, got VEC{}'.format(
ln + 1, n))
except:
raise XYZError('Expected VEC{}, got VEC{}'.format(
ln + 1, entry[0][3:]))
cell[ln] = np.array([float(x) for x in entry[1:]])
pbc[ln] = True
if nvec != pbc.count(True):
raise XYZError('Problem with number of cell vectors')
pbc = tuple(pbc)
arrays = {}
for name in names:
ase_name, cols = properties[name]
if cols == 1:
value = data[name]
else:
value = np.vstack([data[name + str(c)] for c in range(cols)]).T
arrays[ase_name] = value
symbols = None
if 'symbols' in arrays:
symbols = [s.capitalize() for s in arrays['symbols']]
del arrays['symbols']
numbers = None
duplicate_numbers = None
if 'numbers' in arrays:
if symbols is None:
numbers = arrays['numbers']
else:
duplicate_numbers = arrays['numbers']
del arrays['numbers']
charges = None
if 'charges' in arrays:
charges = arrays['charges']
del arrays['charges']
positions = None
if 'positions' in arrays:
positions = arrays['positions']
del arrays['positions']
atoms = Atoms(symbols=symbols,
positions=positions,
numbers=numbers,
charges=charges,
cell=cell,
pbc=pbc,
info=info)
# Read and set constraints
if 'move_mask' in arrays:
if properties['move_mask'][1] == 3:
atoms.set_constraint([
FixCartesian(a, mask=arrays['move_mask'][a, :])
for a in range(natoms)
])
elif properties['move_mask'][1] == 1:
atoms.set_constraint(FixAtoms(mask=~arrays['move_mask']))
else:
raise XYZError('Not implemented constraint')
del arrays['move_mask']
for name, array in arrays.items():
atoms.new_array(name, array)
if duplicate_numbers is not None:
atoms.set_atomic_numbers(duplicate_numbers)
# Load results of previous calculations into SinglePointCalculator
results = {}
for key in list(atoms.info.keys()):
if key in all_properties:
results[key] = atoms.info[key]
# special case for stress- convert to Voigt 6-element form
if key.startswith('stress') and results[key].shape == (3, 3):
stress = results[key]
stress = np.array([
stress[0, 0], stress[1, 1], stress[2, 2], stress[1, 2],
stress[0, 2], stress[0, 1]
])
results[key] = stress
for key in list(atoms.arrays.keys()):
if key in all_properties:
results[key] = atoms.arrays[key]
if results != {}:
calculator = SinglePointCalculator(atoms, **results)
atoms.set_calculator(calculator)
return atoms
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 import Atoms, Atom
from ase.calculators.singlepoint import SinglePointCalculator
from ase.units import Ang, fs
from ase.constraints import FixAtoms, FixCartesian
molecular_dynamics = False
fd = open(filename, 'r')
cell = []
images = []
fix = []
fix_cart = []
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 "Found relaxation constraint for atom" in line:
xyz = [0, 0, 0]
ind = int(line.split()[5][:-1]) - 1
if "All coordinates fixed" in line:
if ind not in fix:
fix.append(ind)
if "coordinate fixed" in line:
coord = line.split()[6]
if coord == 'x':
xyz[0] = 1
elif coord == 'y':
xyz[1] = 1
elif coord == 'z':
xyz[2] = 1
keep = True
for n, c in enumerate(fix_cart):
if ind == c.a:
keep = False
if keep:
fix_cart.append(FixCartesian(ind, xyz))
else:
fix_cart[n].mask[xyz.index(1)] = 0
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()
if 'lattice_vector' in inp[0]:
cell = []
for i in range(3):
cell += [[float(inp[1]), float(inp[2]), float(inp[3])]]
inp = fd.readline().split()
atoms.set_cell(cell)
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)
if len(fix):
atoms.set_constraint([FixAtoms(indices=fix)] + fix_cart)
else:
atoms.set_constraint(fix_cart)
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(atoms, energy=e, forces=f))
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(atoms, energy=e))
if not molecular_dynamics:
if len(fix):
atoms.set_constraint([FixAtoms(indices=fix)] + fix_cart)
else:
atoms.set_constraint(fix_cart)
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/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)]
def read_aims(filename):
"""Import FHI-aims geometry type files.
Reads unitcell, atom positions and constraints from
a geometry.in file.
"""
from ase import Atoms
from ase.constraints import FixAtoms, FixCartesian
import numpy as np
atoms = Atoms()
fd = open(filename, 'r')
lines = fd.readlines()
fd.close()
positions = []
cell = []
symbols = []
magmoms = []
fix = []
fix_cart = []
xyz = np.array([0, 0, 0])
i = -1
n_periodic = -1
periodic = np.array([False, False, False])
cart_positions, scaled_positions = False, False
for n, line in enumerate(lines):
inp = line.split()
if inp == []:
continue
if inp[0] == 'atom':
cart_positions = True
if xyz.all():
fix.append(i)
elif xyz.any():
fix_cart.append(FixCartesian(i, xyz))
floatvect = float(inp[1]), float(inp[2]), float(inp[3])
positions.append(floatvect)
symbols.append(inp[-1])
i += 1
xyz = np.array([0, 0, 0])
if inp[0] == 'atom_frac':
scaled_positions = True
if xyz.all():
fix.append(i)
elif xyz.any():
fix_cart.append(FixCartesian(i, xyz))
floatvect = float(inp[1]), float(inp[2]), float(inp[3])
positions.append(floatvect)
symbols.append(inp[-1])
i += 1
xyz = np.array([0, 0, 0])
elif inp[0] == 'lattice_vector':
floatvect = float(inp[1]), float(inp[2]), float(inp[3])
cell.append(floatvect)
n_periodic = n_periodic + 1
periodic[n_periodic] = True
elif inp[0] == 'initial_moment':
magmoms.append(float(inp[1]))
if inp[0] == 'constrain_relaxation':
if inp[1] == '.true.':
fix.append(i)
elif inp[1] == 'x':
xyz[0] = 1
elif inp[1] == 'y':
xyz[1] = 1
elif inp[1] == 'z':
xyz[2] = 1
if xyz.all():
fix.append(i)
elif xyz.any():
fix_cart.append(FixCartesian(i, xyz))
if cart_positions and scaled_positions:
raise Exception("Can't specify atom positions with mixture of "
'Cartesian and fractional coordinates')
elif scaled_positions and periodic.any():
atoms = Atoms(symbols,
scaled_positions=positions,
cell=cell,
pbc=periodic)
else:
atoms = Atoms(symbols, positions)
if len(magmoms) > 0:
atoms.set_initial_magnetic_moments(magmoms)
if periodic.any():
atoms.set_cell(cell)
atoms.set_pbc(periodic)
if len(fix):
atoms.set_constraint([FixAtoms(indices=fix)] + fix_cart)
else:
atoms.set_constraint(fix_cart)
return atoms
def read_aims(filename, apply_constraints=True):
"""Import FHI-aims geometry type files.
Reads unitcell, atom positions and constraints from
a geometry.in file.
If geometric constraint (symmetry parameters) are in the file
include that information in atoms.info["symmetry_block"]
"""
from ase import Atoms
from ase.constraints import (
FixAtoms,
FixCartesian,
FixScaledParametricRelations,
FixCartesianParametricRelations,
)
import numpy as np
atoms = Atoms()
with open(filename, "r") as fd:
lines = fd.readlines()
positions = []
cell = []
symbols = []
velocities = []
magmoms = []
symmetry_block = []
charges = []
fix = []
fix_cart = []
xyz = np.array([0, 0, 0])
i = -1
n_periodic = -1
periodic = np.array([False, False, False])
cart_positions, scaled_positions = False, False
for line in lines:
inp = line.split()
if inp == []:
continue
if inp[0] == "atom":
cart_positions = True
if xyz.all():
fix.append(i)
elif xyz.any():
fix_cart.append(FixCartesian(i, xyz))
floatvect = float(inp[1]), float(inp[2]), float(inp[3])
positions.append(floatvect)
magmoms.append(0.0)
charges.append(0.0)
symbols.append(inp[-1])
i += 1
xyz = np.array([0, 0, 0])
elif inp[0] == "atom_frac":
scaled_positions = True
if xyz.all():
fix.append(i)
elif xyz.any():
fix_cart.append(FixCartesian(i, xyz))
floatvect = float(inp[1]), float(inp[2]), float(inp[3])
positions.append(floatvect)
magmoms.append(0.0)
symbols.append(inp[-1])
i += 1
xyz = np.array([0, 0, 0])
elif inp[0] == "lattice_vector":
floatvect = float(inp[1]), float(inp[2]), float(inp[3])
cell.append(floatvect)
n_periodic = n_periodic + 1
periodic[n_periodic] = True
elif inp[0] == "initial_moment":
magmoms[-1] = float(inp[1])
elif inp[0] == "initial_charge":
charges[-1] = float(inp[1])
elif inp[0] == "constrain_relaxation":
if inp[1] == ".true.":
fix.append(i)
elif inp[1] == "x":
xyz[0] = 1
elif inp[1] == "y":
xyz[1] = 1
elif inp[1] == "z":
xyz[2] = 1
elif inp[0] == "velocity":
floatvect = [v_unit * float(l) for l in inp[1:4]]
velocities.append(floatvect)
elif inp[0] in [
"symmetry_n_params",
"symmetry_params",
"symmetry_lv",
"symmetry_frac",
]:
symmetry_block.append(" ".join(inp))
if xyz.all():
fix.append(i)
elif xyz.any():
fix_cart.append(FixCartesian(i, xyz))
if cart_positions and scaled_positions:
raise Exception("Can't specify atom positions with mixture of "
"Cartesian and fractional coordinates")
elif scaled_positions and periodic.any():
atoms = Atoms(symbols,
scaled_positions=positions,
cell=cell,
pbc=periodic)
else:
atoms = Atoms(symbols, positions)
if len(velocities) > 0:
if len(velocities) != len(positions):
raise Exception(
"Number of positions and velocities have to coincide.")
atoms.set_velocities(velocities)
fix_params = []
if len(symmetry_block) > 5:
params = symmetry_block[1].split()[1:]
lattice_expressions = []
lattice_params = []
atomic_expressions = []
atomic_params = []
n_lat_param = int(symmetry_block[0].split(" ")[2])
lattice_params = params[:n_lat_param]
atomic_params = params[n_lat_param:]
for ll, line in enumerate(symmetry_block[2:]):
expression = " ".join(line.split(" ")[1:])
if ll < 3:
lattice_expressions += expression.split(",")
else:
atomic_expressions += expression.split(",")
fix_params.append(
FixCartesianParametricRelations.from_expressions(
list(range(3)),
lattice_params,
lattice_expressions,
use_cell=True,
))
fix_params.append(
FixScaledParametricRelations.from_expressions(
list(range(len(atoms))), atomic_params, atomic_expressions))
if any(magmoms):
atoms.set_initial_magnetic_moments(magmoms)
if any(charges):
atoms.set_initial_charges(charges)
if periodic.any():
atoms.set_cell(cell)
atoms.set_pbc(periodic)
if len(fix):
atoms.set_constraint([FixAtoms(indices=fix)] + fix_cart + fix_params)
else:
atoms.set_constraint(fix_cart + fix_params)
if fix_params and apply_constraints:
atoms.set_positions(atoms.get_positions())
return atoms
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 import Atoms, Atom
from ase.calculators.singlepoint import SinglePointCalculator
from ase.constraints import FixAtoms, FixCartesian
molecular_dynamics = False
fd = open(filename, "r")
cell = []
images = []
fix = []
fix_cart = []
f = None
pbc = False
found_aims_calculator = False
stress = None
for line in fd:
# if "List of parameters used to initialize the calculator:" in line:
# next(fd)
# 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 = next(fd).split()
cell.append([inp[1], inp[2], inp[3]])
if "Found relaxation constraint for atom" in line:
xyz = [0, 0, 0]
ind = int(line.split()[5][:-1]) - 1
if "All coordinates fixed" in line:
if ind not in fix:
fix.append(ind)
if "coordinate fixed" in line:
coord = line.split()[6]
if coord == "x":
xyz[0] = 1
elif coord == "y":
xyz[1] = 1
elif coord == "z":
xyz[2] = 1
keep = True
for n, c in enumerate(fix_cart):
if ind == c.a:
keep = False
if keep:
fix_cart.append(FixCartesian(ind, xyz))
else:
fix_cart[n].mask[xyz.index(1)] = 0
if "Atomic structure:" in line and not molecular_dynamics:
next(fd)
atoms = Atoms()
for _ in range(n_atoms):
inp = next(fd).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:
atoms = _parse_atoms(fd, n_atoms=n_atoms)
elif "Atomic structure (and velocities)" in line:
next(fd)
atoms = Atoms()
velocities = []
for i in range(n_atoms):
inp = next(fd).split()
atoms.append(Atom(inp[4], (inp[1], inp[2], inp[3])))
inp = next(fd).split()
floatvect = [v_unit * float(l) for l in inp[1:4]]
velocities.append(floatvect)
atoms.set_velocities(velocities)
if len(fix):
atoms.set_constraint([FixAtoms(indices=fix)] + fix_cart)
else:
atoms.set_constraint(fix_cart)
images.append(atoms)
# if we enter here, the SocketIO/PIMD Wrapper was used
elif ("Atomic structure that "
"was used in the preceding time step of the wrapper") in line:
# parse atoms and add calculator information, i.e., the energies
# and forces that were already collected
atoms = _parse_atoms(fd, n_atoms=n_atoms)
results = images[-1].calc.results
atoms.calc = SinglePointCalculator(atoms, **results)
# replace last image with updated atoms
images[-1] = atoms
# make sure `atoms` does not point to `images[-1` later on
atoms = atoms.copy()
# FlK: add analytical stress and replace stress=None
if "Analytical stress tensor - Symmetrized" in line:
# scroll to significant lines
for _ in range(4):
next(fd)
stress = []
for _ in range(3):
inp = next(fd)
stress.append([float(i) for i in inp.split()[2:5]])
if "Total atomic forces" in line:
f = []
for i in range(n_atoms):
inp = next(fd).split()
# FlK: use inp[-3:] instead of inp[1:4] to make sure this works
# when atom number is not preceded by a space.
f.append([float(i) for i in inp[-3:]])
if not found_aims_calculator:
e = images[-1].get_potential_energy()
# FlK: Add the stress if it has been computed
if stress is None:
calc = SinglePointCalculator(atoms, energy=e, forces=f)
else:
calc = SinglePointCalculator(atoms,
energy=e,
forces=f,
stress=stress)
images[-1].calc = calc
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.calc = SinglePointCalculator(atoms, energy=e)
if not molecular_dynamics:
if len(fix):
atoms.set_constraint([FixAtoms(indices=fix)] + fix_cart)
else:
atoms.set_constraint(fix_cart)
images.append(atoms)
e = None
# if found_aims_calculator:
# calc.set_results(images[-1])
# images[-1].calc = calc
# FlK: add stress per atom
if "Per atom stress (eV) used for heat flux calculation" in line:
# scroll to boundary
next(l for l in fd if "-------------" in l)
stresses = []
for l in [next(fd) for _ in range(n_atoms)]:
# Read stresses
xx, yy, zz, xy, xz, yz = [float(d) for d in l.split()[2:8]]
stresses.append([[xx, xy, xz], [xy, yy, yz], [xz, yz, zz]])
if not found_aims_calculator:
e = images[-1].get_potential_energy()
f = images[-1].get_forces()
stress = images[-1].get_stress(voigt=False)
calc = SinglePointCalculator(atoms,
energy=e,
forces=f,
stress=stress,
stresses=stresses)
images[-1].calc = calc
fd.close()
if molecular_dynamics:
images = images[1:]
# return requested images, code borrowed from ase/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)]
def read_aims(filename):
"""Import FHI-aims geometry type files.
Reads unitcell, atom positions and constraints from
a geometry.in file.
"""
from ase import Atoms
from ase.constraints import FixAtoms, FixCartesian
import numpy as np
atoms = Atoms()
fd = open(filename, 'r')
lines = fd.readlines()
fd.close()
positions = []
cell = []
symbols = []
fix = []
fix_cart = []
xyz = np.array([0, 0, 0])
i = -1
n_periodic = -1
periodic = np.array([False, False, False])
for n, line in enumerate(lines):
inp = line.split()
if inp == []:
continue
if inp[0] == 'atom':
if xyz.all():
fix.append(i)
elif xyz.any():
fix_cart.append(FixCartesian(i, xyz))
floatvect = float(inp[1]), float(inp[2]), float(inp[3])
positions.append(floatvect)
symbols.append(inp[-1])
i += 1
xyz = np.array([0, 0, 0])
elif inp[0] == 'lattice_vector':
floatvect = float(inp[1]), float(inp[2]), float(inp[3])
cell.append(floatvect)
n_periodic = n_periodic + 1
periodic[n_periodic] = True
if inp[0] == 'constrain_relaxation':
if inp[1] == '.true.':
fix.append(i)
elif inp[1] == 'x':
xyz[0] = 1
elif inp[1] == 'y':
xyz[1] = 1
elif inp[1] == 'z':
xyz[2] = 1
if xyz.all():
fix.append(i)
elif xyz.any():
fix_cart.append(FixCartesian(i, xyz))
atoms = Atoms(symbols, positions)
if periodic.all():
atoms.set_cell(cell)
atoms.set_pbc(periodic)
if len(fix):
atoms.set_constraint([FixAtoms(indices=fix)] + fix_cart)
else:
atoms.set_constraint(fix_cart)
return atoms
a = bulk('Si')
a.info['val_1'] = 42.0
a.info['val_2'] = 42.0 # was np.float but that's the same. Can remove
a.info['val_3'] = np.int64(42)
a.write('tmp.xyz')
with open('tmp.xyz', 'r') as fd:
comment_line = fd.readlines()[1]
assert "val_1=42.0" in comment_line and "val_2=42.0" in comment_line and "val_3=42" in comment_line
b = ase.io.read('tmp.xyz')
assert abs(b.info['val_1'] - 42.0) < 1e-6
assert abs(b.info['val_2'] - 42.0) < 1e-6
assert abs(b.info['val_3'] - 42) == 0
@pytest.mark.parametrize('constraint', [FixAtoms(indices=(0, 2)),
FixCartesian(1, mask=(1, 0, 1)),
[FixCartesian(0), FixCartesian(2)]])
def test_constraints(constraint):
atoms = molecule('H2O')
atoms.set_constraint(constraint)
columns = ['symbols', 'positions', 'move_mask']
ase.io.write('tmp.xyz', atoms, columns=columns)
atoms2 = ase.io.read('tmp.xyz')
assert not compare_atoms(atoms, atoms2)
constraint2 = atoms2.constraints
cls = type(constraint)
if cls == FixAtoms:
assert len(constraint2) == 1
def sf_calc(bulk,
n_steps,
z_offset,
p0=None,
p1=None,
relax_from_configs=None):
global bulk_energy
p0 = np.array(p0)
p1 = np.array(p1)
E0 = bulk_energy
surf_unrelaxed = np.zeros((n_steps, n_steps), dtype=(float, 3))
surf_relaxed = np.zeros((n_steps, n_steps), dtype=(float, 3))
path_unrelaxed = []
path_relaxed = []
sf = bulk.copy()
pos = sf.get_positions()
pos[:, 2] += z_offset
sf.set_positions(pos)
pos = sf.get_scaled_positions()
pos -= np.floor(pos)
sf.set_scaled_positions(pos)
if p0 is not None and p1 is not None: # paths
# unrelaxed
for i in range(n_steps):
print "start path unrelaxed step", i
sys.stdout.flush()
p = p0 + (p1 - p0) * i / float(n_steps - 1)
sf_cur = sf.copy()
sf_cur.arrays['move_mask_3'] = np.zeros((len(sf_cur), 3),
dtype=int)
sf_cur.arrays['move_mask_3'][:, 2] = 1
sf_cur.set_calculator(model.calculator)
cell = sf_cur.get_cell()
cell[2, :] += cell[0, :] * p[0] + cell[1, :] * p[1]
sf_cur.set_cell(cell)
E = (sf_cur.get_potential_energy() - E0) / np.linalg.norm(
np.cross(cell[0, :], cell[1, :]))
path_unrelaxed.append((i / float(n_steps - 1), p[0], p[1], E))
# relaxed
sf_cur = sf.copy()
sf_cur.arrays['move_mask_3'] = np.zeros((len(sf_cur), 3), dtype=int)
sf_cur.arrays['move_mask_3'][:, 2] = 1
sf_cur.set_calculator(model.calculator)
dp = (p1 - p0) / float(n_steps - 1)
p = p0.copy()
cell = sf_cur.get_cell()
cell[2, :] += cell[0, :] * p[0] + cell[1, :] * p[1]
sf_cur.set_cell(cell)
relax_from_configs_i = 0
for i in range(n_steps):
print "start path relaxed step", i
sys.stdout.flush()
if model.name == 'CASTEP_file':
sf_cur.calc.fix_all_cell = False
sf_cur.set_constraint(
[FixCartesian(j, [1, 1, 0]) for j in range(len(sf_cur))])
sf_cur.calc.cell_constraints = ["0 0 1", "0 0 0"]
sf_cur.calc._old_atoms = None
if debug:
ase.io.write(file_unrelaxed, sf_cur, "extxyz")
file_unrelaxed.flush()
try:
sf_cur.set_cell(
relax_from_configs[relax_from_configs_i].get_cell(), False)
sf_cur.set_positions(
relax_from_configs[relax_from_configs_i].get_positions())
print "got sf_cur from 'relax_from_configs'"
sys.stdout.flush()
except:
pass
sf_cur_rel = relax_atoms_cell(
sf_cur,
tol=tol,
method='cg_n',
max_steps=500,
traj_file=None,
mask=[False, False, True, False, False, False])
relax_from_configs_i += 1
if debug:
ase.io.write(file_relaxed, sf_cur, "extxyz")
file_relaxed.flush()
print "done relaxation"
sys.stdout.flush()
E = (sf_cur.get_potential_energy() - E0) / np.linalg.norm(
np.cross(cell[0, :], cell[1, :]))
path_relaxed.append((i / float(n_steps - 1), p[0], p[1], E))
cell = sf_cur.get_cell()
cell[2, :] += cell[0, :] * dp[0] + cell[1, :] * dp[1]
sf_cur.set_cell(cell)
p += dp
return (path_unrelaxed, path_relaxed)
else: # surfaces
# unrelaxed
j_doffset = sf.get_cell()[1, :] * (1.0 / float(n_steps - 1))
for i in range(n_steps):
x_i = float(i) / float(n_steps - 1)
sf_cur = sf.copy()
sf_cur.arrays['move_mask_3'] = np.zeros((len(sf_cur), 3),
dtype=int)
sf_cur.arrays['move_mask_3'][:, 2] = 1
sf_cur.set_calculator(model.calculator)
cell = sf_cur.get_cell()
cell[2, :] += cell[0, :] * x_i
sf_cur.set_cell(cell)
for j in range(n_steps - i):
x_j = float(j) / float(n_steps - 1)
print(i, j, x_i, x_j)
if debug:
ase.io.write(file_unrelaxed, sf_cur, "extxyz")
file_unrelaxed.flush()
E = (sf_cur.get_potential_energy() - E0) / np.linalg.norm(
np.cross(cell[0, :], cell[1, :]))
surf_unrelaxed[i, j] = (x_i, x_j, E)
if i + j != n_steps - 1:
surf_unrelaxed[n_steps - j - 1,
n_steps - i - 1] = (1.0 - x_j, 1.0 - x_i, E)
cell = sf_cur.get_cell()
cell[2, :] += j_doffset
sf_cur.set_cell(cell, scale_atoms=False)
# relaxed
relax_from_configs_i = 0
j_doffset = sf.get_cell()[1, :] * (1.0 / float(n_steps - 1))
for i in range(n_steps):
x_i = float(i) / float(n_steps - 1)
sf_cur = sf.copy()
# set constraints
# cs = []
# for i_at in range(len(bulk)):
# cs.append(FixCartesian(i_at, mask=[0,0,1]))
# sf_cur.set_constraint(cs)
sf_cur.arrays['move_mask_3'] = np.zeros((len(sf_cur), 3),
dtype=int)
sf_cur.arrays['move_mask_3'][:, 2] = 1
sf_cur.set_calculator(model.calculator)
cell = sf_cur.get_cell()
cell[2, :] += cell[0, :] * x_i
sf_cur.set_cell(cell)
for j in range(n_steps - i):
x_j = float(j) / float(n_steps - 1)
print(i, j, x_i, x_j)
try:
sf_cur.set_cell(
relax_from_configs[relax_from_configs_i].get_cell(),
False)
sf_cur.set_positions(
relax_from_configs[relax_from_configs_i].get_positions(
))
except:
pass
sf_cur_rel = relax_atoms_cell(
sf_cur,
tol=tol,
method='cg_n',
max_steps=500,
traj_file=None,
mask=[False, False, True, False, False, False])
relax_from_configs_i += 1
if debug:
ase.io.write(file_relaxed, sf_cur_rel, "extxyz")
file_relaxed.flush()
E = (sf_cur_rel.get_potential_energy() - E0) / np.linalg.norm(
np.cross(cell[0, :], cell[1, :]))
surf_relaxed[i, j] = (x_i, x_j, E)
if i + j != n_steps - 1:
surf_relaxed[n_steps - j - 1,
n_steps - i - 1] = (1.0 - x_j, 1.0 - x_i, E)
cell = sf_cur.get_cell()
cell[2, :] += j_doffset
sf_cur.set_cell(cell, scale_atoms=False)
return (surf_unrelaxed, surf_relaxed)
def read_aims(filename):
"""Import FHI-aims geometry type files.
Reads unitcell, atom positions and constraints from
a geometry.in file.
"""
from ase import Atoms
from ase.constraints import FixAtoms, FixCartesian
import numpy as np
atoms = Atoms()
fd = open(filename, "r")
lines = fd.readlines()
fd.close()
positions = []
cell = []
symbols = []
velocities = []
magmoms = []
fix = []
fix_cart = []
xyz = np.array([0, 0, 0])
i = -1
n_periodic = -1
periodic = np.array([False, False, False])
cart_positions, scaled_positions = False, False
for n, line in enumerate(lines):
inp = line.split()
if inp == []:
continue
if inp[0] == "atom":
cart_positions = True
if xyz.all():
fix.append(i)
elif xyz.any():
fix_cart.append(FixCartesian(i, xyz))
floatvect = float(inp[1]), float(inp[2]), float(inp[3])
positions.append(floatvect)
symbols.append(inp[-1])
i += 1
xyz = np.array([0, 0, 0])
elif inp[0] == "atom_frac":
scaled_positions = True
if xyz.all():
fix.append(i)
elif xyz.any():
fix_cart.append(FixCartesian(i, xyz))
floatvect = float(inp[1]), float(inp[2]), float(inp[3])
positions.append(floatvect)
symbols.append(inp[-1])
i += 1
xyz = np.array([0, 0, 0])
elif inp[0] == "lattice_vector":
floatvect = float(inp[1]), float(inp[2]), float(inp[3])
cell.append(floatvect)
n_periodic = n_periodic + 1
periodic[n_periodic] = True
elif inp[0] == "initial_moment":
magmoms.append(float(inp[1]))
elif inp[0] == "constrain_relaxation":
if inp[1] == ".true.":
fix.append(i)
elif inp[1] == "x":
xyz[0] = 1
elif inp[1] == "y":
xyz[1] = 1
elif inp[1] == "z":
xyz[2] = 1
elif inp[0] == "velocity":
floatvect = [v_unit * float(l) for l in inp[1:4]]
velocities.append(floatvect)
if xyz.all():
fix.append(i)
elif xyz.any():
fix_cart.append(FixCartesian(i, xyz))
if cart_positions and scaled_positions:
raise Exception("Can't specify atom positions with mixture of "
"Cartesian and fractional coordinates")
elif scaled_positions and periodic.any():
atoms = Atoms(symbols,
scaled_positions=positions,
cell=cell,
pbc=periodic)
else:
atoms = Atoms(symbols, positions)
if len(velocities) > 0:
if len(velocities) != len(positions):
raise Exception(
"Number of positions and velocities have to coincide.")
atoms.set_velocities(velocities)
if len(magmoms) > 0:
atoms.set_initial_magnetic_moments(magmoms)
if periodic.any():
atoms.set_cell(cell)
atoms.set_pbc(periodic)
if len(fix):
atoms.set_constraint([FixAtoms(indices=fix)] + fix_cart)
else:
atoms.set_constraint(fix_cart)
return atoms
