def build_system(self, name):
try:
# Known molecule or atom?
atoms = molecule(name)
if len(atoms) == 2 and self.bond_length is not None:
atoms.set_distance(0, 1, self.bond_length)
except NotImplementedError:
symbols = string2symbols(name)
if len(symbols) == 1:
magmom = ground_state_magnetic_moments[atomic_numbers[
symbols[0]]]
atoms = Atoms(name, magmoms=[magmom])
elif len(symbols) == 2:
# Dimer
if self.bond_length is None:
b = (covalent_radii[atomic_numbers[symbols[0]]] +
covalent_radii[atomic_numbers[symbols[1]]])
else:
b = self.bond_length
atoms = Atoms(name, positions=[(0, 0, 0), (b, 0, 0)])
else:
raise ValueError('Unknown molecule: ' + name)
if self.unit_cell is None:
atoms.center(vacuum=self.vacuum)
else:
atoms.cell = self.unit_cell
atoms.center()
return atoms
def build_system(self, name):
try:
# Known molecule or atom?
atoms = molecule(name)
if len(atoms) == 2 and self.bond_length is not None:
atoms.set_distance(0, 1, self.bond_length)
except NotImplementedError:
symbols = string2symbols(name)
if len(symbols) == 1:
Z = atomic_numbers[symbols[0]]
magmom = ground_state_magnetic_moments[Z]
atoms = Atoms(name, magmoms=[magmom])
elif len(symbols) == 2:
# Dimer
if self.bond_length is None:
b = (covalent_radii[atomic_numbers[symbols[0]]] +
covalent_radii[atomic_numbers[symbols[1]]])
else:
b = self.bond_length
atoms = Atoms(name, positions=[(0, 0, 0),
(b, 0, 0)])
else:
raise ValueError('Unknown molecule: ' + name)
if self.unit_cell is None:
atoms.center(vacuum=self.vacuum)
else:
atoms.cell = self.unit_cell
atoms.center()
return atoms
def build_molecule(args):
try:
# Known molecule or atom?
atoms = molecule(args.name)
except NotImplementedError:
symbols = string2symbols(args.name)
if len(symbols) == 1:
Z = atomic_numbers[symbols[0]]
magmom = ground_state_magnetic_moments[Z]
atoms = Atoms(args.name, magmoms=[magmom])
elif len(symbols) == 2:
# Dimer
if args.bond_length is None:
b = (covalent_radii[atomic_numbers[symbols[0]]] +
covalent_radii[atomic_numbers[symbols[1]]])
else:
b = args.bond_length
atoms = Atoms(args.name, positions=[(0, 0, 0),
(b, 0, 0)])
else:
raise ValueError('Unknown molecule: ' + args.name)
else:
if len(atoms) == 2 and args.bond_length is not None:
atoms.set_distance(0, 1, args.bond_length)
if args.unit_cell is None:
if args.vacuum:
atoms.center(vacuum=args.vacuum)
else:
atoms.center(about=[0, 0, 0])
else:
a = [float(x) for x in args.unit_cell.split(',')]
if len(a) == 1:
cell = [a[0], a[0], a[0]]
elif len(a) == 3:
cell = a
else:
a, b, c, alpha, beta, gamma = a
degree = np.pi / 180.0
cosa = np.cos(alpha * degree)
cosb = np.cos(beta * degree)
sinb = np.sin(beta * degree)
cosg = np.cos(gamma * degree)
sing = np.sin(gamma * degree)
cell = [[a, 0, 0],
[b * cosg, b * sing, 0],
[c * cosb, c * (cosa - cosb * cosg) / sing,
c * np.sqrt(
sinb**2 - ((cosa - cosb * cosg) / sing)**2)]]
atoms.cell = cell
atoms.center()
atoms.pbc = args.periodic
return atoms
def parse_relax(label,
write_traj=False,
pbc=False,
cell=None,
chemical_symbols=[]):
f = open(label + '.relax')
#f = open(label + '.restart')
text = f.read()
# Parse out the steps
if text == '':
return None
steps = text.split(':RELAXSTEP:')[1:]
if write_traj == False:
steps = [steps[-1]]
else:
traj = Trajectory(label + '.traj', mode='w')
# Parse out the energies
n_geometric = len(steps)
s = os.popen('grep "Total free energy" ' + label + '.out')
engs = s.readlines()[-n_geometric:]
engs = [float(a.split()[-2]) * Hartree for a in engs]
s.close()
# build a traj file out of the steps
for j, step in enumerate(steps):
positions = step.split(':')[2].strip().split('\n')
forces = step.split(':')[4].strip().split('\n')
frc = np.empty((len(forces), 3))
atoms = Atoms()
for i, f in enumerate(forces):
frc[i, :] = [float(a) * Hartree / Bohr for a in f.split()]
atoms += Atom(chemical_symbols[i],
[float(a) * Bohr for a in positions[i].split()])
atoms.set_calculator(
SinglePointCalculator(atoms, energy=engs[j], forces=frc))
atoms.set_pbc(pbc)
atoms.cell = cell
if write_traj == True:
traj.write(atoms)
atoms.set_calculator()
return atoms
def graphene_nanoribbon(n,
m,
type='zigzag',
saturated=False,
C_H=1.09,
C_C=1.42,
vacuum=None,
magnetic=False,
initial_mag=1.12,
sheet=False,
main_element='C',
saturate_element='H'):
"""Create a graphene nanoribbon.
Creates a graphene nanoribbon in the x-z plane, with the nanoribbon
running along the z axis.
Parameters:
n: int
The width of the nanoribbon. For armchair nanoribbons, this
n may be half-integer to repeat by half a cell.
m: int
The length of the nanoribbon.
type: str
The orientation of the ribbon. Must be either 'zigzag'
or 'armchair'.
saturated: bool
If true, hydrogen atoms are placed along the edge.
C_H: float
Carbon-hydrogen bond length. Default: 1.09 Angstrom.
C_C: float
Carbon-carbon bond length. Default: 1.42 Angstrom.
vacuum: None (default) or float
Amount of vacuum added to non-periodic directions, if present.
magnetic: bool
Make the edges magnetic.
initial_mag: float
Magnitude of magnetic moment if magnetic.
sheet: bool
If true, make an infinite sheet instead of a ribbon (default: False)
"""
if m % 1 != 0:
raise ValueError('m must be integer')
if type == 'zigzag' and n % 1 != 0:
raise ValueError('n must be an integer for zigzag ribbons')
b = sqrt(3) * C_C / 4
arm_unit = Atoms(main_element + '4',
pbc=(1, 0, 1),
cell=[4 * b, 0, 3 * C_C])
arm_unit.positions = [[0, 0, 0], [b * 2, 0, C_C / 2.],
[b * 2, 0, 3 * C_C / 2.], [0, 0, 2 * C_C]]
arm_unit_half = Atoms(main_element + '2',
pbc=(1, 0, 1),
cell=[2 * b, 0, 3 * C_C])
arm_unit_half.positions = [[b * 2, 0, C_C / 2.], [b * 2, 0, 3 * C_C / 2.]]
zz_unit = Atoms(main_element + '2',
pbc=(1, 0, 1),
cell=[3 * C_C / 2.0, 0, b * 4])
zz_unit.positions = [[0, 0, 0], [C_C / 2.0, 0, b * 2]]
atoms = Atoms()
if type == 'zigzag':
edge_index0 = np.arange(m) * 2
edge_index1 = (n - 1) * m * 2 + np.arange(m) * 2 + 1
if magnetic:
mms = np.zeros(m * n * 2)
for i in edge_index0:
mms[i] = initial_mag
for i in edge_index1:
mms[i] = -initial_mag
for i in range(n):
layer = zz_unit.repeat((1, 1, m))
layer.positions[:, 0] += 3 * C_C / 2 * i
if i % 2 == 1:
layer.positions[:, 2] += 2 * b
layer[-1].position[2] -= b * 4 * m
atoms += layer
xmin = atoms.positions[0, 0]
if magnetic:
atoms.set_initial_magnetic_moments(mms)
if saturated:
H_atoms0 = Atoms(saturate_element + str(m))
H_atoms0.positions = atoms[edge_index0].positions
H_atoms0.positions[:, 0] -= C_H
H_atoms1 = Atoms(saturate_element + str(m))
H_atoms1.positions = atoms[edge_index1].positions
H_atoms1.positions[:, 0] += C_H
atoms += H_atoms0 + H_atoms1
atoms.cell = [n * 3 * C_C / 2, 0, m * 4 * b]
elif type == 'armchair':
n *= 2
n_int = int(round(n))
if abs(n_int - n) > 1e-10:
raise ValueError(
'The argument n has to be half-integer for armchair ribbons.')
n = n_int
for i in range(n // 2):
layer = arm_unit.repeat((1, 1, m))
layer.positions[:, 0] -= 4 * b * i
atoms += layer
if n % 2:
layer = arm_unit_half.repeat((1, 1, m))
layer.positions[:, 0] -= 4 * b * (n // 2)
atoms += layer
xmin = atoms.positions[-1, 0]
if saturated:
if n % 2:
arm_right_saturation = Atoms(saturate_element + '2',
pbc=(1, 0, 1),
cell=[2 * b, 0, 3 * C_C])
arm_right_saturation.positions = [[
-sqrt(3) / 2 * C_H, 0, C_C / 2 - C_H * 0.5
], [-sqrt(3) / 2 * C_H, 0, 3 * C_C / 2.0 + C_H * 0.5]]
else:
arm_right_saturation = Atoms(saturate_element + '2',
pbc=(1, 0, 1),
cell=[4 * b, 0, 3 * C_C])
arm_right_saturation.positions = [[
-sqrt(3) / 2 * C_H, 0, C_H * 0.5
], [-sqrt(3) / 2 * C_H, 0, 2 * C_C - C_H * 0.5]]
arm_left_saturation = Atoms(saturate_element + '2',
pbc=(1, 0, 1),
cell=[4 * b, 0, 3 * C_C])
arm_left_saturation.positions = [[
b * 2 + sqrt(3) / 2 * C_H, 0, C_C / 2 - C_H * 0.5
], [b * 2 + sqrt(3) / 2 * C_H, 0, 3 * C_C / 2.0 + C_H * 0.5]]
arm_right_saturation.positions[:, 0] -= 4 * b * (n / 2.0 - 1)
atoms += arm_right_saturation.repeat((1, 1, m))
atoms += arm_left_saturation.repeat((1, 1, m))
atoms.cell = [b * 4 * n / 2.0, 0, 3 * C_C * m]
atoms.set_pbc([sheet, False, True])
# The ribbon was 'built' from x=0 towards negative x.
# Move the ribbon to positive x:
atoms.positions[:, 0] -= xmin
if not sheet:
atoms.cell[0] = 0.0
if vacuum is not None:
atoms.center(vacuum, axis=1)
if not sheet:
atoms.center(vacuum, axis=0)
return atoms
def graphene_nanoribbon(n,
m,
type='zigzag',
saturated=False,
C_H=1.09,
C_C=1.42,
vacuum=None,
magnetic=False,
initial_mag=1.12,
sheet=False,
main_element='C',
saturate_element='H'):
"""Create a graphene nanoribbon.
Creates a graphene nanoribbon in the x-z plane, with the nanoribbon
running along the z axis.
Parameters:
n: int
The width of the nanoribbon.
m: int
The length of the nanoribbon.
type: str
The orientation of the ribbon. Must be either 'zigzag'
or 'armchair'.
saturated: bool
If true, hydrogen atoms are placed along the edge.
C_H: float
Carbon-hydrogen bond length. Default: 1.09 Angstrom.
C_C: float
Carbon-carbon bond length. Default: 1.42 Angstrom.
vacuum: None (default) or float
Amount of vacuum added to non-periodic directions, if present.
magnetic: bool
Make the edges magnetic.
initial_mag: float
Magnitude of magnetic moment if magnetic.
sheet: bool
If true, make an infinite sheet instead of a ribbon (default: False)
"""
b = sqrt(3) * C_C / 4
arm_unit = Atoms(main_element + '4',
pbc=(1, 0, 1),
cell=[4 * b, 0, 3 * C_C])
arm_unit.positions = [[0, 0, 0], [b * 2, 0, C_C / 2.],
[b * 2, 0, 3 * C_C / 2.], [0, 0, 2 * C_C]]
zz_unit = Atoms(main_element + '2',
pbc=(1, 0, 1),
cell=[3 * C_C / 2.0, 0, b * 4])
zz_unit.positions = [[0, 0, 0], [C_C / 2.0, 0, b * 2]]
atoms = Atoms()
if type == 'zigzag':
edge_index0 = np.arange(m) * 2 + 1
edge_index1 = (n - 1) * m * 2 + np.arange(m) * 2
if magnetic:
mms = np.zeros(m * n * 2)
for i in edge_index0:
mms[i] = initial_mag
for i in edge_index1:
mms[i] = -initial_mag
for i in range(n):
layer = zz_unit.repeat((1, 1, m))
layer.positions[:, 0] -= 3 * C_C / 2 * i
if i % 2 == 1:
layer.positions[:, 2] += 2 * b
layer[-1].position[2] -= b * 4 * m
atoms += layer
if magnetic:
atoms.set_initial_magnetic_moments(mms)
if saturated:
H_atoms0 = Atoms(saturate_element + str(m))
H_atoms0.positions = atoms[edge_index0].positions
H_atoms0.positions[:, 0] += C_H
H_atoms1 = Atoms(saturate_element + str(m))
H_atoms1.positions = atoms[edge_index1].positions
H_atoms1.positions[:, 0] -= C_H
atoms += H_atoms0 + H_atoms1
atoms.cell = [n * 3 * C_C / 2, 0, m * 4 * b]
elif type == 'armchair':
for i in range(n):
layer = arm_unit.repeat((1, 1, m))
layer.positions[:, 0] -= 4 * b * i
atoms += layer
if saturated:
arm_right_saturation = Atoms(saturate_element + '2',
pbc=(1, 0, 1),
cell=[4 * b, 0, 3 * C_C])
arm_right_saturation.positions = [[
-sqrt(3) / 2 * C_H, 0, C_H * 0.5
], [-sqrt(3) / 2 * C_H, 0, 2 * C_C - C_H * 0.5]]
arm_left_saturation = Atoms(saturate_element + '2',
pbc=(1, 0, 1),
cell=[4 * b, 0, 3 * C_C])
arm_left_saturation.positions = [[
b * 2 + sqrt(3) / 2 * C_H, 0, C_C / 2 - C_H * 0.5
], [b * 2 + sqrt(3) / 2 * C_H, 0, 3 * C_C / 2.0 + C_H * 0.5]]
arm_right_saturation.positions[:, 0] -= 4 * b * (n - 1)
atoms += arm_right_saturation.repeat((1, 1, m))
atoms += arm_left_saturation.repeat((1, 1, m))
atoms.cell = [b * 4 * n, 0, 3 * C_C * m]
atoms.set_pbc([sheet, False, True])
atoms.set_scaled_positions(atoms.get_scaled_positions() % 1.0)
if not sheet:
atoms.cell[0] = 0.0
if vacuum:
atoms.center(vacuum, axis=1)
if not sheet:
atoms.center(vacuum, axis=0)
return atoms
#!/usr/bin/env python
from xcp2k import CP2K
from ase.atoms import Atom, Atoms
from ase.lattice import bulk
import numpy as np
from multiprocessing import Pool, Process
import os
atoms = Atoms([Atom('Pt', (0, 0, 0))])
atoms.cell=0.5 * 3.96 * np.array([[1.0, 1.0, 0.0],
[0.0, 1.0, 1.0],
[1.0, 0.0, 1.0]])
atoms = atoms*[4, 4, 4]
atoms.pbc = [True, True, True]
def run(cutoff, atoms):
kwargs = {'label': 'conv/cutoff/{0}/pt-{0}'.format(cutoff, cutoff),
'xc': 'PBE',
'scf_guess': 'atomic',
'max_scf': 500,
'EPS_SCF': 5.0E-7,
'added_mos': 500,
'sme/method': 'fermi_dirac',
'ELECTRONIC_TEMPERATURE': 300,
'DIA/ALGORITHM': 'STANDARD',
'mix/METHOD': 'BROYDEN_MIXING',
def graphene_nanoribbon(
n,
m,
type="zigzag",
saturated=False,
C_H=1.09,
C_C=1.42,
vacuum=2.5,
magnetic=None,
initial_mag=1.12,
sheet=False,
main_element="C",
saturate_element="H",
vacc=None,
):
"""Create a graphene nanoribbon.
Creates a graphene nanoribbon in the x-z plane, with the nanoribbon
running along the z axis.
Parameters:
n: The width of the nanoribbon
m: The length of the nanoribbon.
type ('zigzag'): The orientation of the ribbon. Must be either 'zigzag'
or 'armchair'.
saturated (Falsi): If true, hydrogen atoms are placed along the edge.
C_H: Carbon-hydrogen bond length. Default: 1.09 Angstrom
C_C: Carbon-carbon bond length. Default: 1.42 Angstrom.
vacuum: Amount of vacuum added to both sides. Default 2.5 Angstrom.
magnetic: Make the edges magnetic.
initial_mag: Magnitude of magnetic moment if magnetic=True.
sheet: If true, make an infinite sheet instead of a ribbon.
"""
# This function creates the coordinates for a graphene nanoribbon,
# n is width, m is length
if vacc is not None:
warnings.warn("Use vacuum=%f" % (0.5 * vacc))
vacuum = 0.5 * vacc
assert vacuum > 0
b = sqrt(3) * C_C / 4
arm_unit = Atoms(main_element + "4", pbc=(1, 0, 1), cell=[4 * b, 2 * vacuum, 3 * C_C])
arm_unit.positions = [[0, 0, 0], [b * 2, 0, C_C / 2.0], [b * 2, 0, 3 * C_C / 2.0], [0, 0, 2 * C_C]]
zz_unit = Atoms(main_element + "2", pbc=(1, 0, 1), cell=[3 * C_C / 2.0, 2 * vacuum, b * 4])
zz_unit.positions = [[0, 0, 0], [C_C / 2.0, 0, b * 2]]
atoms = Atoms()
tol = 1e-4
if sheet:
vacuum2 = 0.0
else:
vacuum2 = vacuum
if type == "zigzag":
edge_index0 = np.arange(m) * 2 + 1
edge_index1 = (n - 1) * m * 2 + np.arange(m) * 2
if magnetic:
mms = np.zeros(m * n * 2)
for i in edge_index0:
mms[i] = initial_mag
for i in edge_index1:
mms[i] = -initial_mag
for i in range(n):
layer = zz_unit.repeat((1, 1, m))
layer.positions[:, 0] -= 3 * C_C / 2 * i
if i % 2 == 1:
layer.positions[:, 2] += 2 * b
layer[-1].position[2] -= b * 4 * m
atoms += layer
if magnetic:
atoms.set_initial_magnetic_moments(mms)
if saturated:
H_atoms0 = Atoms(saturate_element + str(m))
H_atoms0.positions = atoms[edge_index0].positions
H_atoms0.positions[:, 0] += C_H
H_atoms1 = Atoms(saturate_element + str(m))
H_atoms1.positions = atoms[edge_index1].positions
H_atoms1.positions[:, 0] -= C_H
atoms += H_atoms0 + H_atoms1
atoms.cell = [n * 3 * C_C / 2 + 2 * vacuum2, 2 * vacuum, m * 4 * b]
elif type == "armchair":
for i in range(n):
layer = arm_unit.repeat((1, 1, m))
layer.positions[:, 0] -= 4 * b * i
atoms += layer
atoms.cell = [b * 4 * n + 2 * vacuum2, 2 * vacuum, 3 * C_C * m]
atoms.center()
atoms.set_pbc([sheet, False, True])
return atoms
def graphene_nanoribbon(n, m, type='zigzag', saturated=False, C_H=1.09,
C_C=1.42, vacuum=2.5, magnetic=None, initial_mag=1.12,
sheet=False, main_element='C', saturate_element='H',
vacc=None):
"""Create a graphene nanoribbon.
Creates a graphene nanoribbon in the x-z plane, with the nanoribbon
running along the z axis.
Parameters:
n: int
The width of the nanoribbon.
m: int
The length of the nanoribbon.
type: str
The orientation of the ribbon. Must be either 'zigzag'
or 'armchair'.
saturated: bool
If true, hydrogen atoms are placed along the edge.
C_H: float
Carbon-hydrogen bond length. Default: 1.09 Angstrom.
C_C: float
Carbon-carbon bond length. Default: 1.42 Angstrom.
vacuum: float
Amount of vacuum added to both sides. Default 2.5 Angstrom.
magnetic: bool
Make the edges magnetic.
initial_mag: float
Magnitude of magnetic moment if magnetic=True.
sheet: bool
If true, make an infinite sheet instead of a ribbon.
"""
if vacc is not None:
warnings.warn('Use vacuum=%f' % (0.5 * vacc))
vacuum = 0.5 * vacc
assert vacuum > 0
b = sqrt(3) * C_C / 4
arm_unit = Atoms(main_element + '4',
pbc=(1, 0, 1),
cell=[4 * b, 2 * vacuum, 3 * C_C])
arm_unit.positions = [[0, 0, 0],
[b * 2, 0, C_C / 2.],
[b * 2, 0, 3 * C_C / 2.],
[0, 0, 2 * C_C]]
zz_unit = Atoms(main_element + '2',
pbc=(1, 0, 1),
cell=[3 * C_C / 2.0, 2 * vacuum, b * 4])
zz_unit.positions = [[0, 0, 0],
[C_C / 2.0, 0, b * 2]]
atoms = Atoms()
if sheet:
vacuum2 = 0.0
else:
vacuum2 = vacuum
if type == 'zigzag':
edge_index0 = np.arange(m) * 2 + 1
edge_index1 = (n - 1) * m * 2 + np.arange(m) * 2
if magnetic:
mms = np.zeros(m * n * 2)
for i in edge_index0:
mms[i] = initial_mag
for i in edge_index1:
mms[i] = -initial_mag
for i in range(n):
layer = zz_unit.repeat((1, 1, m))
layer.positions[:, 0] -= 3 * C_C / 2 * i
if i % 2 == 1:
layer.positions[:, 2] += 2 * b
layer[-1].position[2] -= b * 4 * m
atoms += layer
if magnetic:
atoms.set_initial_magnetic_moments(mms)
if saturated:
H_atoms0 = Atoms(saturate_element + str(m))
H_atoms0.positions = atoms[edge_index0].positions
H_atoms0.positions[:, 0] += C_H
H_atoms1 = Atoms(saturate_element + str(m))
H_atoms1.positions = atoms[edge_index1].positions
H_atoms1.positions[:, 0] -= C_H
atoms += H_atoms0 + H_atoms1
atoms.cell = [n * 3 * C_C / 2 + 2 * vacuum2, 2 * vacuum, m * 4 * b]
elif type == 'armchair':
for i in range(n):
layer = arm_unit.repeat((1, 1, m))
layer.positions[:, 0] -= 4 * b * i
atoms += layer
if saturated:
arm_right_saturation = Atoms(saturate_element + '2', pbc=(1, 0, 1),
cell=[4 * b, 2 * vacuum, 3 * C_C])
arm_right_saturation.positions = [
[- sqrt(3) / 2 * C_H, 0, C_H * 0.5],
[- sqrt(3) / 2 * C_H, 0, 2 * C_C - C_H * 0.5]]
arm_left_saturation = Atoms(saturate_element + '2', pbc=(1, 0, 1),
cell=[4 * b, 2 * vacuum, 3 * C_C])
arm_left_saturation.positions = [
[b * 2 + sqrt(3) / 2 * C_H, 0, C_C / 2 - C_H * 0.5],
[b * 2 + sqrt(3) / 2 * C_H, 0, 3 * C_C / 2.0 + C_H * 0.5]]
arm_right_saturation.positions[:, 0] -= 4 * b * (n - 1)
atoms += arm_right_saturation.repeat((1, 1, m))
atoms += arm_left_saturation.repeat((1, 1, m))
atoms.cell = [b * 4 * n + 2 * vacuum2, 2 * vacuum, 3 * C_C * m]
atoms.center()
atoms.set_pbc([sheet, False, True])
return atoms
def read_gromacs(filename):
""" From:
http://manual.gromacs.org/current/online/gro.html
C format
"%5d%-5s%5s%5d%8.3f%8.3f%8.3f%8.4f%8.4f%8.4f"
python: starting from 0, including first excluding last
0:4 5:10 10:15 15:20 20:28 28:36 36:44 44:52 52:60 60:68
Import gromacs geometry type files (.gro).
Reads atom positions,
velocities(if present) and
simulation cell (if present)
"""
atoms = Atoms()
filed = open(filename, 'r')
lines = filed.readlines()
filed.close()
positions = []
gromacs_velocities = []
symbols = []
tags = []
gromacs_residuenumbers = []
gromacs_residuenames = []
gromacs_atomtypes = []
sym2tag = {}
tag = 0
for line in (lines[2:-1]):
# print(line[0:5]+':'+line[5:11]+':'+line[11:15]+':'+line[15:20])
# it is not a good idea to use the split method with gromacs input
# since the fields are defined by a fixed column number. Therefore,
# they may not be space between the fields
# inp = line.split()
floatvect = float(line[20:28]) * 10.0, \
float(line[28:36]) * 10.0, \
float(line[36:44]) * 10.0
positions.append(floatvect)
# read velocities
velocities = np.array([0.0, 0.0, 0.0])
vx = line[44:52].strip()
vy = line[52:60].strip()
vz = line[60:68].strip()
for iv, vxyz in enumerate([vx, vy, vz]):
if len(vxyz) > 0:
try:
velocities[iv] = float(vxyz)
except ValueError:
raise ValueError("can not convert velocity to float")
else:
velocities = None
if velocities is not None:
# velocities from nm/ps to ase units
velocities *= units.nm / (1000.0 * units.fs)
gromacs_velocities.append(velocities)
gromacs_residuenumbers.append(int(line[0:5]))
gromacs_residuenames.append(line[5:11].strip())
symbol_read = line[11:16].strip()[0:2]
if symbol_read not in sym2tag.keys():
sym2tag[symbol_read] = tag
tag += 1
tags.append(sym2tag[symbol_read])
if symbol_read in atomic_numbers:
symbols.append(symbol_read)
elif symbol_read[0] in atomic_numbers:
symbols.append(symbol_read[0])
elif symbol_read[-1] in atomic_numbers:
symbols.append(symbol_read[-1])
else:
# not an atomic symbol
# if we can not determine the symbol, we use
# the dummy symbol X
symbols.append("X")
gromacs_atomtypes.append(line[11:16].strip())
line = lines[-1]
atoms = Atoms(symbols, positions, tags=tags)
if len(gromacs_velocities) == len(atoms):
atoms.set_velocities(gromacs_velocities)
elif len(gromacs_velocities) != 0:
raise ValueError("Some atoms velocities were not specified!")
if not atoms.has('residuenumbers'):
atoms.new_array('residuenumbers', gromacs_residuenumbers, int)
atoms.set_array('residuenumbers', gromacs_residuenumbers, int)
if not atoms.has('residuenames'):
atoms.new_array('residuenames', gromacs_residuenames, str)
atoms.set_array('residuenames', gromacs_residuenames, str)
if not atoms.has('atomtypes'):
atoms.new_array('atomtypes', gromacs_atomtypes, str)
atoms.set_array('atomtypes', gromacs_atomtypes, str)
# determine PBC and unit cell
atoms.pbc = False
inp = lines[-1].split()
try:
grocell = list(map(float, inp))
except ValueError:
return atoms
if len(grocell) < 3:
return atoms
cell = np.diag(grocell[:3])
if len(grocell) >= 9:
cell.flat[[1, 2, 3, 5, 6, 7]] = grocell[3:9]
atoms.cell = cell * 10.
atoms.pbc = True
return atoms
def parse_MD(label,
write_traj=False,
pbc=False,
cell=None,
chemical_symbols=[]):
f = open(label + '.aimd')
#f = open(label + '.restart')
text = f.read()
if text == '':
return None
# Parse out the steps
steps = text.split(':MDSTEP:')[1:]
if write_traj == False:
steps = [steps[-1]]
else:
traj = Trajectory(label + '.traj', mode='w')
# Parse out the energies
n_images = len(steps)
s = os.popen('grep ":FEN:" ' + label + '.aimd')
engs = s.readlines()[-n_images:]
engs = [float(a.split()[-1]) * Hartree for a in engs]
s.close()
# build a traj file out of the steps
for j, step in enumerate(steps):
# Find Indicies
colons = step.split(':')
#pos_index = colons.index('R(Bohr)') + 1
#frc_index = colons.index('F(Ha/Bohr)') + 1
#vel_index = colons.index('V(Bohr/atu)') + 1
pos_index = colons.index('R') + 1
frc_index = colons.index('F') + 1
vel_index = colons.index('V') + 1
# Parse the text
positions = colons[pos_index].strip().split('\n')
forces = colons[frc_index].strip().split('\n')
velocities = colons[vel_index].strip().split('\n')
# Initialize the arrays
frc = np.empty((len(forces), 3))
vel = np.empty((len(velocities), 3))
stress = np.zeros((3, 3))
atoms = Atoms()
for i, f, v in zip(range(len(forces)), forces, velocities):
frc[i, :] = [float(a) * Hartree / Bohr for a in f.split()]
vel[i, :] = [float(a) / Bohr / fs for a in v.split()]
atoms += Atom(chemical_symbols[i],
[float(a) * Bohr for a in positions[i].split()])
if 'STRESS' in step:
stress_index = colons.index('STRESS_TOT(GPa)') + 1
for i, s in enumerate(colons[stress_index].strip().split('\n')):
stress[i, :] = [float(a) * GPa for a in s.split()]
atoms.set_velocities(vel)
atoms.set_pbc(pbc)
atoms.cell = cell
atoms.set_calculator(
SinglePointCalculator(atoms,
energy=engs[j] * len(atoms),
stress=stress,
forces=frc))
if write_traj == True:
traj.write(atoms)
atoms.set_calculator()
return atoms
#!/usr/bin/env python
from xcp2k import CP2K
from ase.atoms import Atom, Atoms
from ase.lattice import bulk
import numpy as np
from multiprocessing import Pool, Process
import os
from ase.eos import EquationOfState
import time
atoms = Atoms([Atom('Pt', (0.0, 0.0, 0.0)),
Atom('Pt', (2.0, 2.0, 0.0)),
Atom('Pt', (2.0, 0.0, 2.0)),
Atom('Pt', (0.0, 2.0, 2.0))])
atoms.cell= 4.0 * np.array([[1.0, 0.0, 0.0],
[0.0, 1.0, 0.0],
[0.0, 0.0, 1.0]])
atoms = atoms*[1, 1, 1]
atoms.pbc = [True, True, True]
kwargs = {'label': 'relax/111/relax',
'xc': 'PBE',
'scf_guess': 'atomic',
'max_scf': 500,
'EPS_SCF': 5.0E-7,
'added_mos': 500,
'sme/method': 'fermi_dirac',
'ELECTRONIC_TEMPERATURE': 300,
def graphene_nanoribbon(n,
m,
type='zigzag',
saturated=False,
C_H=1.09,
C_C=1.42,
vacuum=2.5,
magnetic=None,
initial_mag=1.12,
sheet=False,
main_element='C',
saturate_element='H',
vacc=None):
"""Create a graphene nanoribbon.
Creates a graphene nanoribbon in the x-z plane, with the nanoribbon
running along the z axis.
Parameters:
n: The width of the nanoribbon
m: The length of the nanoribbon.
type ('zigzag'): The orientation of the ribbon. Must be either 'zigzag'
or 'armchair'.
saturated (Falsi): If true, hydrogen atoms are placed along the edge.
C_H: Carbon-hydrogen bond length. Default: 1.09 Angstrom
C_C: Carbon-carbon bond length. Default: 1.42 Angstrom.
vacuum: Amount of vacuum added to both sides. Default 2.5 Angstrom.
magnetic: Make the edges magnetic.
initial_mag: Magnitude of magnetic moment if magnetic=True.
sheet: If true, make an infinite sheet instead of a ribbon.
"""
#This function creates the coordinates for a graphene nanoribbon,
#n is width, m is length
if vacc is not None:
warnings.warn('Use vacuum=%f' % (0.5 * vacc))
vacuum = 0.5 * vacc
assert vacuum > 0
b = sqrt(3) * C_C / 4
arm_unit = Atoms(main_element + '4',
pbc=(1, 0, 1),
cell=[4 * b, 2 * vacuum, 3 * C_C])
arm_unit.positions = [[0, 0, 0], [b * 2, 0, C_C / 2.],
[b * 2, 0, 3 * C_C / 2.], [0, 0, 2 * C_C]]
zz_unit = Atoms(main_element + '2',
pbc=(1, 0, 1),
cell=[3 * C_C / 2., 2 * vacuum, b * 4])
zz_unit.positions = [[0, 0, 0], [C_C / 2., 0, b * 2]]
atoms = Atoms()
tol = 1e-4
if sheet:
vacuum2 = 0.0
else:
vacuum2 = vacuum
if type == 'zigzag':
edge_index0 = np.arange(m) * 2 + 1
edge_index1 = (n - 1) * m * 2 + np.arange(m) * 2
if magnetic:
mms = np.zeros(m * n * 2)
for i in edge_index0:
mms[i] = initial_mag
for i in edge_index1:
mms[i] = -initial_mag
for i in range(n):
layer = zz_unit.repeat((1, 1, m))
layer.positions[:, 0] -= 3 * C_C / 2 * i
if i % 2 == 1:
layer.positions[:, 2] += 2 * b
layer[-1].position[2] -= b * 4 * m
atoms += layer
if magnetic:
atoms.set_initial_magnetic_moments(mms)
if saturated:
H_atoms0 = Atoms(saturate_element + str(m))
H_atoms0.positions = atoms[edge_index0].positions
H_atoms0.positions[:, 0] += C_H
H_atoms1 = Atoms(saturate_element + str(m))
H_atoms1.positions = atoms[edge_index1].positions
H_atoms1.positions[:, 0] -= C_H
atoms += H_atoms0 + H_atoms1
atoms.cell = [n * 3 * C_C / 2 + 2 * vacuum2, 2 * vacuum, m * 4 * b]
elif type == 'armchair':
for i in range(n):
layer = arm_unit.repeat((1, 1, m))
layer.positions[:, 0] -= 4 * b * i
atoms += layer
atoms.cell = [b * 4 * n + 2 * vacuum2, 2 * vacuum, 3 * C_C * m]
atoms.center()
atoms.set_pbc([sheet, False, True])
return atoms
