def write_dftb(filename, atoms):
"""Method to write atom structure in DFTB+ format
(gen format)
"""
import numpy as np
#sort
atoms.set_masses()
masses = atoms.get_masses()
indexes = np.argsort(masses)
atomsnew = Atoms()
for i in indexes:
atomsnew = atomsnew + atoms[i]
if isinstance(filename, str):
myfile = open(filename, 'w')
else: # Assume it's a 'file-like object'
myfile = filename
ispbc = atoms.get_pbc()
box = atoms.get_cell()
if (any(ispbc)):
myfile.write('%8d %2s \n' % (len(atoms), 'S'))
else:
myfile.write('%8d %2s \n' % (len(atoms), 'C'))
chemsym = atomsnew.get_chemical_symbols()
allchem = ''
for i in chemsym:
if i not in allchem:
allchem = allchem + i + ' '
myfile.write(allchem + ' \n')
coords = atomsnew.get_positions()
itype = 1
for iatom, coord in enumerate(coords):
if iatom > 0:
if chemsym[iatom] != chemsym[iatom - 1]:
itype = itype + 1
myfile.write('%5i%5i %19.16f %19.16f %19.16f \n' \
%(iatom+1, itype,
coords[iatom][0], coords[iatom][1], coords[iatom][2]))
# write box
if (any(ispbc)):
#dftb dummy
myfile.write(' %19.16f %19.16f %19.16f \n' % (0, 0, 0))
myfile.write(' %19.16f %19.16f %19.16f \n' %
(box[0][0], box[0][1], box[0][2]))
myfile.write(' %19.16f %19.16f %19.16f \n' %
(box[1][0], box[1][1], box[1][2]))
myfile.write(' %19.16f %19.16f %19.16f \n' %
(box[2][0], box[2][1], box[2][2]))
if type(filename) == str:
myfile.close()
def test_successful_run():
"""test run and parent run"""
with db.connect('database.db') as fdb:
data = {'runner': copy(runner)}
id_ = fdb.write(Atoms(), data=data, status='submit:terminal:test')
data['runner']['parents'] = [id_]
id_1 = fdb.write(Atoms(), data=data, status='submit:terminal:test')
# waiting on next pass
data = {'runner': copy(runner)}
data['runner']['tasks'][0][1] = 'sleep 7'
id_2 = fdb.write(Atoms(), data=data, status='submit:terminal:test')
# test max jobs and keep run
data['runner']['tasks'][0][1] = 'sleep 1'
data['runner']['keep_run'] = True
id_3 = fdb.write(Atoms(), data=data, status='submit:terminal:test')
run = TerminalRunner('test', max_jobs=2)
run.spool(_endless=False)
fdb = db.connect('database.db')
assert fdb.get(id_).status == 'running:terminal:test'
assert fdb.get(id_1).status == 'submit:terminal:test'
assert fdb.get(id_2).status == 'running:terminal:test'
assert fdb.get(id_3).status == 'submit:terminal:test'
time.sleep(5)
run.spool(_endless=False)
assert fdb.get(id_).status == 'done:terminal:test'
assert fdb.get(id_1).status == 'running:terminal:test'
assert fdb.get(id_2).status == 'running:terminal:test'
assert fdb.get(id_3).status == 'submit:terminal:test'
time.sleep(5)
run.spool(_endless=False)
assert fdb.get(id_).status == 'done:terminal:test'
assert fdb.get(id_1).status == 'done:terminal:test'
assert fdb.get(id_2).status == 'done:terminal:test'
assert fdb.get(id_3).status == 'running:terminal:test'
time.sleep(5)
run.spool(_endless=False)
assert fdb.get(id_3).status == 'done:terminal:test'
assert not str(id_) in os.listdir(), 'no cleanup after done'
assert not str(id_1) in os.listdir(), 'no cleanup after done'
assert not str(id_2) in os.listdir(), 'no cleanup after done'
assert str(id_3) in os.listdir(), 'keep_run failed'
def _build_rhl(name, a, alpha, basis):
from ase.lattice import RHL
lat = RHL(a, alpha)
cell = lat.tocell()
if basis is None:
# RHL: Given by A&M as scaled coordinates "x" of cell.sum(0):
basis_x = reference_states[atomic_numbers[name]]['basis_x']
basis = basis_x[:, None].repeat(3, axis=1)
natoms = len(basis)
return Atoms([name] * natoms, cell=cell, scaled_positions=basis, pbc=True)
def write_xyz(self):
# writes a xyz file
# the import is only needed here
from ase.io import write
bohr = 0.5291772105638411
# unit conversion from bohr to angstroem
pos = np.array(self.calc.positions())*bohr
sym = self.get_chemical_symbols()
atoms = Atoms(sym,pos)
write('pyeff.xyz',atoms,'xyz')
def view(self):
# use ase.gui for visualization
# the import is only needed here
from ase.visualize import view
bohr = 0.5291772105638411
# unit conversion from bohr to angstroem
pos = np.array(self.calc.positions())*bohr
sym = self.get_chemical_symbols()
atoms = Atoms(sym,pos)
view(atoms)
def get_ase(f_file, p_insert_red, s_insert_red):
""" Combine framework and insert atoms to one ase structure
f_file : framework file name
p_insert_red: positions of reduced inserted species
s_insert_red: symbols of reduced inserted species
"""
struct = read(f_file)
insert = Atoms(s_insert_red, p_insert_red)
struct_tot = struct + insert
view(struct_tot)
def read_pdb(fileobj, index=-1):
"""Read PDB files.
The format is assumed to follow the description given in
http://www.wwpdb.org/documentation/format32/sect8.html and
http://www.wwpdb.org/documentation/format32/sect9.html."""
if isinstance(fileobj, str):
fileobj = open(fileobj)
images = []
orig = np.identity(3)
trans = np.zeros(3)
atoms = Atoms()
for line in fileobj.readlines():
if line.startswith('CRYST1'):
cellpar = [float(word) for word in line[6:54].split()]
atoms.set_cell(cellpar_to_cell(cellpar))
for c in range(3):
if line.startswith('ORIGX' + '123'[c]):
pars = [float(word) for word in line[10:55].split()]
orig[c] = pars[:3]
trans[c] = pars[3]
if line.startswith('ATOM') or line.startswith('HETATM'):
try:
# Atom name is arbitrary and does not necessarily contain the element symbol.
# The specification requires the element symbol to be in columns 77+78.
symbol = line[76:78].strip().lower().capitalize()
words = line[30:55].split()
position = np.array(
[float(words[0]),
float(words[1]),
float(words[2])])
position = np.dot(orig, position) + trans
atoms.append(Atom(symbol, position))
except:
pass
if line.startswith('ENDMDL'):
images.append(atoms)
atoms = Atoms()
if len(images) == 0:
images.append(atoms)
return images[index]
def test_write_dftb_velocities():
atoms = Atoms('H2')
velocities = np.linspace(-1, 2, num=6).reshape(2, 3)
atoms.set_velocities(velocities)
write_dftb_velocities(atoms, filename='velocities.txt')
velocities = np.loadtxt('velocities.txt') * Bohr / AUT
assert np.allclose(velocities, atoms.get_velocities())
def read_proteindatabank(fileobj, index=-1):
"""Read PDB files."""
if isinstance(fileobj, basestring):
fileobj = open(fileobj)
images = []
orig = np.identity(3)
trans = np.zeros(3)
atoms = Atoms()
for line in fileobj.readlines():
if line.startswith('CRYST1'):
cellpar = [float(word) for word in line[6:54].split()]
atoms.set_cell(cellpar_to_cell(cellpar))
atoms.pbc = True
for c in range(3):
if line.startswith('ORIGX' + '123'[c]):
pars = [float(word) for word in line[10:55].split()]
orig[c] = pars[:3]
trans[c] = pars[3]
if line.startswith('ATOM') or line.startswith('HETATM'):
try:
# Atom name is arbitrary and does not necessarily
# contain the element symbol. The specification
# requires the element symbol to be in columns 77+78.
symbol = line[76:78].strip().lower().capitalize()
words = line[30:55].split()
position = np.array(
[float(words[0]),
float(words[1]),
float(words[2])])
position = np.dot(orig, position) + trans
atoms.append(Atom(symbol, position))
except Exception as ex:
warnings.warn(
'Discarding atom when reading PDB file: {}'.format(ex))
if line.startswith('ENDMDL'):
images.append(atoms)
atoms = Atoms()
if len(images) == 0:
images.append(atoms)
return images[index]
def graphene(formula='C2', a=2.460, size=(1, 1, 1), vacuum=None):
"""Create a graphene monolayer structure."""
cell = [[a, 0, 0], [-a / 2, a * 3**0.5 / 2, 0], [0, 0, 0]]
basis = [[0, 0, 0], [2./3, 1./3, 0]]
atoms = Atoms(formula, cell=cell, pbc=(1, 1, 0))
atoms.set_scaled_positions(basis)
if vacuum is not None:
atoms.center(vacuum, axis=2)
atoms = atoms.repeat(size)
return atoms
async def dumb_fio_task(cid, calc, atcor, ian, cell=None, pbc=None):
import numpy as np
from ase.atoms import Atoms
mol = Atoms(numbers=ian, positions=atcor, cell=cell, pbc=pbc)
mol.calc = calc
mol._calc.write_input(mol, ['energy', 'forces'], [])
return (
0.0,
np.zeros_like(atcor),
)
def test_co_kernel_derivative(self):
direction = np.array([1., 2., 3.])
direction /= np.linalg.norm(direction)
atoms = Atoms(['C', 'O'],
positions=np.array([-0.5 * direction, 0.5 * direction]))
atoms.set_calculator(EMT())
def to_radius(x):
xyzs = x.get_positions()
r = np.sqrt(np.sum((xyzs[1, :] - xyzs[0, :])**2))
dr = np.zeros((1, 6))
dr[0, 0] = (xyzs[0, 0] - xyzs[1, 0]) / r
dr[0, 1] = (xyzs[0, 1] - xyzs[1, 1]) / r
dr[0, 2] = (xyzs[0, 2] - xyzs[1, 2]) / r
dr[0, 3] = (xyzs[1, 0] - xyzs[0, 0]) / r
dr[0, 4] = (xyzs[1, 1] - xyzs[0, 1]) / r
dr[0, 5] = (xyzs[1, 2] - xyzs[0, 2]) / r
return [r], dr
kernel = RBFKernel(constant=100.0, length_scale=0.23)
calc = NCGPRCalculator(input_transform=to_radius,
kernel=kernel,
C1=1e8,
C2=1e8,
opt_restarts=0)
calc.add_data(atoms)
K = calc.build_kernel_matrix()
K_num = np.zeros_like(K)
# kernel value is not tested:
K_num[0, 0] = K[0, 0]
x0 = atoms.get_positions()
dx = 1e-4
def K_fun(x, y):
a = np.array([to_radius(Atoms(['C', 'O'], positions=x))[0]])
b = np.array([to_radius(Atoms(['C', 'O'], positions=y))[0]])
return calc.kernel(a, b, dx=True, dy=True)[0, 0]
for i in range(6):
dxi = np.zeros(6)
dxi[i] = dx
dxi = dxi.reshape((2, 3))
# Test first derivative
K_num[1 + i, 0] = self.num_dx_forth_order(K_fun, x0, x0, dxi)
for j in range(6):
dxj = np.zeros(6)
dxj[j] = dx
dxj = dxj.reshape((2, 3))
K_num[1 + i, 1 + j] = self.num_dxdy_forth_order(
K_fun, x0, x0, dxi, dxj)
# Test symmetry of derivatives
K_num[0, 1 + i] = self.num_dy_forth_order(K_fun, x0, x0, dxi)
np.testing.assert_allclose(K, K_num, atol=1E-5)
def read_atoms(self):
var = self.nc.variables
cell = var['primitive_vectors']
assert cell.units == 'atomic units'
species = var['atom_species'][:]
spos = var['reduced_atom_positions'][:]
numbers = var['atomic_numbers'][:]
return Atoms(numbers=numbers[species - 1],
scaled_positions=spos,
cell=cell[:] * Bohr,
pbc=True)
def build_atoms(positions, method, cell, alat):
"""Creates the atoms for a quantum espresso in file."""
if method != 'crystal':
raise NotImplementedError('Only supported for crystal method of '
'ATOMIC_POSITIONS, not %s.' % method)
atoms = Atoms()
for el, (x, y, z) in positions:
atoms.append(Atom(el, (x, y, z)))
cell *= f2f(alat) * units.Bohr
atoms.set_cell(cell, scale_atoms=True)
return atoms
def build_crystal(a, b, c, al, be, ga):
from ase.atoms import Atoms
if (al+be+ga > 350): return
if (al+be < 1.1*ga): return
if (al+ga < 1.1*be): return
if (be+ga < 1.1*al): return
atms = Atoms('Mg', positions=[(0, 0, 0)],
cell=[a, b, c, al, be, ga], pbc=True)
atms._test_data = [a, b, c, al*pi/180, be*pi/180, ga*pi/180]
return atms
def read_gaussian_out(filename, index=-1, quantity='atoms'):
""""Interface to GaussianReader and returns various quantities"""
energy = 0.0
data = GR(filename)[index]
formula = data['Chemical_formula']
positions = np.array(data['Positions'])
method = data['Method']
version = data['Version']
if method.lower()[1:] in allowed_dft_functionals:
method = 'HF'
atoms = Atoms(formula, positions=positions)
for key, value in data.items():
if (key in method):
energy = value
try:
# Re-read in the log file
f = open(filename, 'r')
lines = f.readlines()
f.close()
forces = list()
for n, line in enumerate(lines):
if ('Forces (Hartrees/Bohr)' in line):
for j in range(len(atoms)):
forces += [[
float(lines[n + j + 3].split()[2]),
float(lines[n + j + 3].split()[3]),
float(lines[n + j + 3].split()[4])
]]
convert = ase.units.Hartree / ase.units.Bohr
forces = np.array(forces) * convert
except:
forces = None
energy *= ase.units.Hartree # Convert the energy from a.u. to eV
calc = SinglePointCalculator(atoms, energy=energy, forces=forces)
atoms.set_calculator(calc)
if (quantity == 'energy'):
return energy
elif (quantity == 'forces'):
return forces
elif (quantity == 'dipole'):
return data['Dipole']
elif (quantity == 'atoms'):
return atoms
elif (quantity == 'version'):
return version
def getAseAtomsObjFromPylibUCell(inpUCell):
scaledPositions = [x[:-1] for x in inpUCell.fractCoords
] #We remove the atom symbol from the end
symbols = inpUCell._elementList #Will be None if never set, which is fine
lattVects = inpUCell.lattVects
pbcs = True
outObj = Atoms(scaled_positions=scaledPositions,
symbols=symbols,
cell=lattVects,
pbc=pbcs)
return outObj
def test_read_dftb_explicit():
x = 1.356773
positions = [[0., 0., 0.], [x, x, x]]
cell = [[2 * x, 2 * x, 0.], [0., 2 * x, 2 * x], [2 * x, 0., 2 * x]]
atoms = Atoms('GaAs', cell=cell, positions=positions, pbc=True)
atoms_new = read_dftb(fd_explicit)
assert np.all(atoms_new.numbers == atoms.numbers)
assert np.allclose(atoms_new.positions, atoms.positions)
assert np.all(atoms_new.pbc == atoms.pbc)
assert np.allclose(atoms_new.cell, atoms.cell)
def _orthorhombic_bulk(name, x, a, covera=None):
if x == 'fcc':
b = a / sqrt(2)
atoms = Atoms(2 * name,
cell=(b, b, a),
pbc=True,
scaled_positions=[(0, 0, 0), (0.5, 0.5, 0.5)])
elif x == 'bcc':
atoms = Atoms(2 * name,
cell=(a, a, a),
pbc=True,
scaled_positions=[(0, 0, 0), (0.5, 0.5, 0.5)])
elif x == 'hcp':
atoms = Atoms(4 * name,
cell=(a, a * sqrt(3), covera * a),
scaled_positions=[(0, 0, 0), (0.5, 0.5, 0),
(0.5, 1.0 / 6.0, 0.5),
(0, 2.0 / 3.0, 0.5)],
pbc=True)
elif x == 'diamond':
atoms = _orthorhombic_bulk(2 * name, 'zincblende', a)
elif x == 'zincblende':
s1, s2 = string2symbols(name)
b = a / sqrt(2)
atoms = Atoms(2 * name,
cell=(b, b, a),
pbc=True,
scaled_positions=[(0, 0, 0), (0.5, 0, 0.25),
(0.5, 0.5, 0.5), (0, 0.5, 0.75)])
elif x == 'rocksalt':
s1, s2 = string2symbols(name)
b = a / sqrt(2)
atoms = Atoms(2 * name,
cell=(b, b, a),
pbc=True,
scaled_positions=[(0, 0, 0), (0.5, 0.5, 0),
(0.5, 0.5, 0.5), (0, 0, 0.5)])
else:
raise RuntimeError
return atoms
def unpack_reftraj_str_to_atoms(data):
lines = data.split('\n')
label = int(lines[0])
n_atoms = int(lines[1])
at = Atoms(symbols=[' ']*n_atoms, cell=np.eye(3))
at.info['label'] = label
for i in range(3):
at.cell[:, i] = [float(x) for x in lines[i].split()]
for i, line in enumerate(lines[4:]):
t = [float(x) for x in line.split()]
at.positions[i, :] = np.dot(at.cell.T, t)
return at
def __get_optimised_molecule_and_energy_from_xyz(self, fileobj):
lines = fileobj.readlines()
natoms = int(lines[0])
total_energy_kcal_mol = float(lines[1].split()[1]) * Hartree * mol / kcal # store energy in kcal/mol
symbols = []
positions = []
for line in lines[2:2 + natoms]:
symbol, x, y, z = line.split()[:4]
symbol = symbol.lower().capitalize()
symbols.append(symbol)
positions.append([float(x), float(y), float(z)])
return Atoms(symbols=symbols, positions=positions), total_energy_kcal_mol
def read_turbomole(filename='coord'):
"""Method to read turbomole coord file
coords in bohr, atom types in lowercase, format:
$coord
x y z atomtype
x y z atomtype f
$end
Above 'f' means a fixed atom.
"""
from ase import Atoms, Atom
from ase.constraints import FixAtoms
if isinstance(filename, str):
f = open(filename)
lines = f.readlines()
atoms_pos = []
atom_symbols = []
dollar_count=0
myconstraints=[]
for line in lines:
if ('$' in line):
dollar_count = dollar_count + 1
if (dollar_count >= 2):
break
else:
x, y, z, symbolraw = line.split()[:4]
symbolshort=symbolraw.strip()
symbol=symbolshort[0].upper()+symbolshort[1:].lower()
#print symbol
atom_symbols.append(symbol)
atoms_pos.append([float(x)*Bohr, float(y)*Bohr, float(z)*Bohr])
cols = line.split()
if (len(cols) == 5):
fixedstr = line.split()[4].strip()
if (fixedstr == "f"):
myconstraints.append(True)
else:
myconstraints.append(False)
else:
myconstraints.append(False)
if type(filename) == str:
f.close()
atoms = Atoms(positions = atoms_pos, symbols = atom_symbols, pbc = False)
c = FixAtoms(myconstraints)
atoms.set_constraint(c)
#print c
return atoms
def as_ase(self):
atoms = Atoms(positions=self.positions,
cell=self.cell,
pbc=self.pbc,
numbers=self.numbers)
atoms.calc = self.calc # DONE: e, f
if atoms.calc is not None:
atoms.calc.atoms = atoms
vel = self.get_velocities()
if vel is not None:
atoms.set_velocities(vel)
return atoms
def createCH3(self):
rot = xRotation(2 / 3 * pi)
mpow = np.linalg.matrix_power
h_coords = array((-cos(c_angle), 0, sin(c_angle))) * ch_length
pos = [
np.zeros((3)), h_coords,
dot(rot, h_coords),
dot(mpow(rot, 2), h_coords)
]
atoms = Atoms('CH3', pos)
atoms.info['bonds'] = Bonds(atoms, pairs=((0, 1), (0, 2), (0, 3)))
return atoms
def __getitem__(self, i=-1):
if isinstance(i, slice):
return [self[j] for j in range(*i.indices(len(self)))]
N = len(self.offsets)
if 0 <= i < N:
self.fd.seek(self.offsets[i])
try:
d = pickle.load(self.fd, encoding='bytes')
d = {
k.decode() if isinstance(k, bytes) else k: v
for k, v in d.items()
}
except EOFError:
raise IndexError
if i == N - 1:
self.offsets.append(self.fd.tell())
charges = d.get('charges')
magmoms = d.get('magmoms')
try:
constraints = [c.copy() for c in self.constraints]
except:
constraints = []
warnings.warn('Constraints did not unpickle correctly.')
atoms = Atoms(positions=d['positions'],
numbers=self.numbers,
cell=d['cell'],
momenta=d['momenta'],
magmoms=magmoms,
charges=charges,
tags=self.tags,
masses=self.masses,
pbc=self.pbc,
info=unstringnify_info(d.get('info', {})),
constraint=constraints)
if 'energy' in d:
calc = SinglePointCalculator(atoms,
energy=d.get('energy', None),
forces=d.get('forces', None),
stress=d.get('stress', None),
magmoms=magmoms)
atoms.set_calculator(calc)
return atoms
if i >= N:
for j in range(N - 1, i + 1):
atoms = self[j]
return atoms
i = len(self) + i
if i < 0:
raise IndexError('Trajectory index out of range.')
return self[i]
def test_atoms_getitem():
w = Atoms('H2O',
positions=[[2.264, 0.639, 0.876], [0.792, 0.955, 0.608],
[1.347, 0.487, 1.234]],
cell=[3, 3, 3],
pbc=True)
with pytest.raises(IndexError):
w[True, False]
assert (w[0, 1] == w[True, True, False])
assert (w[0, 1] == w[0:2])
def run(opt, args):
images = Images()
if opt.aneb:
opt.image_number = '-1'
if len(args) > 0:
from ase.io import string2index
try:
images.read(args, string2index(opt.image_number))
except IOError as e:
if len(e.args) == 1:
parser.error(e.args[0])
else:
parser.error(e.args[1] + ': ' + e.filename)
else:
images.initialize([Atoms()])
if opt.interpolate:
images.interpolate(opt.interpolate)
if opt.aneb:
images.aneb()
if opt.repeat != '1':
r = opt.repeat.split(',')
if len(r) == 1:
r = 3 * r
images.repeat_images([int(c) for c in r])
if opt.radii_scale:
images.set_radii(opt.radii_scale)
if opt.output is not None:
images.write(opt.output,
rotations=opt.rotations,
show_unit_cell=opt.show_unit_cell)
opt.terminal = True
if opt.terminal:
if opt.graph is not None:
data = images.graph(opt.graph)
for line in data.T:
for x in line:
print(x, end=' ')
print()
else:
from ase.gui.gui import GUI
import ase.gui.gtkexcepthook
ase
gui = GUI(images, opt.rotations, opt.show_unit_cell, opt.bonds)
gui.run(opt.graph)
def test_gfn1_xtb_3d():
"""Test ASE interface to GFN1-xTB"""
thr = 5.0e-6
atoms = Atoms(
symbols="C4O8",
positions=np.array([
[0.9441259872, 0.9437851680, 0.9543505632],
[3.7179966528, 0.9556570368, 3.7316862240],
[3.7159517376, 3.7149292800, 0.9692330016],
[0.9529872864, 3.7220864832, 3.7296981120],
[1.6213905408, 1.6190616096, 1.6313879040],
[0.2656685664, 0.2694175776, 0.2776540416],
[4.3914553920, 1.6346256864, 3.0545920000],
[3.0440834880, 0.2764611744, 4.4080419264],
[4.3910577696, 3.0416409504, 0.2881058304],
[3.0399936576, 4.3879335936, 1.6497353376],
[0.2741322432, 4.4003734944, 3.0573754368],
[1.6312174944, 3.0434586528, 4.4023048032],
]),
cell=np.array([5.68032, 5.68032, 5.68032]),
pbc=np.array([True, True, True]),
)
forces = np.array([
[-0.08831700, -0.07001294, -0.07468651],
[-0.03556765, -0.02242341, +0.03047788],
[+0.03228896, -0.03948204, -0.02892694],
[-0.02569098, +0.03373080, -0.03161988],
[-1.90306812, -1.90236730, -1.90612450],
[+1.98861177, +1.96958105, +1.97849378],
[-1.88898997, -1.93509024, +1.91692369],
[+1.92988257, +1.95061533, -1.94116843],
[-1.93844982, +1.93069254, +1.96026641],
[+1.91146115, -1.88620597, -1.93901862],
[+1.94936349, -1.94760369, +1.92150003],
[-1.93152440, +1.91856587, -1.88611692],
])
stress = np.array([
+4.49045792e-02,
+4.49168887e-02,
+4.49566951e-02,
+3.38245641e-05,
+1.52117499e-05,
+1.13328271e-04,
])
atoms.calc = TBLite(method="GFN1-xTB")
assert atoms.pbc.all()
assert approx(atoms.get_potential_energy(), abs=thr) == -1257.0801067985549
assert approx(atoms.get_forces(), abs=thr) == forces
assert approx(atoms.get_stress(), abs=thr) == stress
def __init__(self, sisl_hamiltonian, spin=None):
self.ham = sisl_hamiltonian
# k2Rfactor : H(k) = \int_R H(R) * e^(k2Rfactor * k.R)
self.R2kfactor = -2.0j*np.pi #
if spin=='up':
spin=0
elif spin=='down':
spin=1
if spin not in [ None, 0, 1, 'merge']:
raise ValueError("spin should be None/0/1, but is %s"%spin)
self.spin=spin
self.orbs=[]
self.orb_dict=defaultdict(lambda:[])
g=self.ham._geometry
_atoms=self.ham._geometry._atoms
atomic_numbers=[]
self.positions=g.xyz
self.cell=np.array(g.sc.cell)
for ia, a in enumerate(_atoms):
atomic_numbers.append(a.Z)
self.atoms=Atoms(numbers=atomic_numbers, cell=self.cell, positions=self.positions)
sdict=list(symbol_number(self.atoms).keys())
if self.ham.spin.is_colinear and (self.spin in [0,1]):
for ia, a in enumerate(_atoms):
symnum=sdict[ia]
try:
orb_names=[f"{symnum}|{x.name()}|up" for x in a.orbital]
except:
orb_names=[f"{symnum}|{x.name()}|up" for x in a.orbitals]
self.orbs+=orb_names
self.orb_dict[ia]+=orb_names
self.norb = len(self.orbs)
self.nbasis=self.norb
elif self.ham.spin.is_spinorbit or self.spin=='merge':
for spin in {'up', 'down'}:
for ia, a in enumerate(_atoms):
symnum=sdict[ia]
orb_names=[]
try:
for x in a.orbital: # sisl < v0.10
orb_names.append(f"{symnum}|{x.name()}|{spin}")
except:
for x in a.orbitals: # sisl >= v0.10
orb_names.append(f"{symnum}|{x.name()}|{spin}")
self.orbs+=orb_names
self.orb_dict[ia]+=orb_names
#print(self.orb_dict)
self.norb=len(self.orbs)//2
#print(f"Norb: {self.norb}")
self.nbasis= len(self.orbs)
else:
raise ValueError("The hamiltonian should be either spin-orbit or colinear")
def read_crystal(filename):
"""Method to read coordinates form 'fort.34' files
additionally read information about
periodic boundary condition
"""
with open(filename, 'r') as myfile:
lines = myfile.readlines()
atoms_pos = []
anumber_list = []
my_pbc = [False, False, False]
mycell = []
if float(lines[4]) != 1:
raise ValueError('High symmetry geometry is not allowed.')
if float(lines[1].split()[0]) < 500.0:
cell = [float(c) for c in lines[1].split()]
mycell.append(cell)
my_pbc[0] = True
else:
mycell.append([1, 0, 0])
if float(lines[2].split()[1]) < 500.0:
cell = [float(c) for c in lines[2].split()]
mycell.append(cell)
my_pbc[1] = True
else:
mycell.append([0, 1, 0])
if float(lines[3].split()[2]) < 500.0:
cell = [float(c) for c in lines[3].split()]
mycell.append(cell)
my_pbc[2] = True
else:
mycell.append([0, 0, 1])
natoms = int(lines[9].split()[0])
for i in range(natoms):
index = 10 + i
anum = int(lines[index].split()[0]) % 100
anumber_list.append(anum)
position = [float(p) for p in lines[index].split()[1:]]
atoms_pos.append(position)
atoms = Atoms(positions=atoms_pos,
numbers=anumber_list,
cell=mycell,
pbc=my_pbc)
return atoms
