def structure(cls):
larray = np.array([[0, .5, .5], [.5, 0, .5], [.5, .5, 0]])
alat = 6.058
structure = DataFactory('structure')(cell=larray * alat)
structure.append_atom(position=[0, 0, 0], symbols='In')
structure.append_atom(position=[.25, .25, .25], symbols='As')
return structure
def structure():
"""Create a StructureData object which can be used in tests"""
larray = np.array([[0, .5, .5], [.5, 0, .5], [.5, .5, 0]])
alat = 6.058
structure = DataFactory('structure')(cell=larray * alat)
structure.append_atom(position=[0, 0, 0], symbols='In')
structure.append_atom(position=[.25, .25, .25], symbols='As')
return structure
def vasp_structure(request, aiida_env):
"""Fixture: StructureData or CifData"""
from aiida_vasp.backendtests.common import subpath
from aiida.orm import DataFactory
if request.param == 'cif':
cif_path = subpath('data', 'EntryWithCollCode43360.cif')
structure = DataFactory('cif').get_or_create(cif_path)[0]
elif request.param == 'str':
larray = numpy.array([[0, .5, .5], [.5, 0, .5], [.5, .5, 0]])
alat = 6.058
structure = DataFactory('structure')(cell=larray * alat)
structure.append_atom(position=[0, 0, 0], symbols='In')
structure.append_atom(position=[.25, .25, .25], symbols='As')
structure.append_atom(position=[.25, .33, .34], symbols='As')
structure.append_atom(position=[.5, .5, .5], symbols='In', name='In_d')
structure.append_atom(position=[.7896, .6234, .5],
symbols='In',
name='In_d')
structure.append_atom(position=[.75, .75, .75], symbols='As')
return structure
def test_simple(self):
import numpy as np
from aiida.orm import DataFactory
s = DataFactory('structure')(cell=[[4, 0, 0], [0, 4, 0], [0, 0, 6]])
s.append_atom(symbols='Ba', position=[0, 0, 0])
s.append_atom(symbols='Ti', position=[2, 2, 3])
s.append_atom(symbols='O', position=[2, 2, 0])
s.append_atom(symbols='O', position=[2, 0, 3])
s.append_atom(symbols='O', position=[0, 2, 3])
retdict = get_explicit_k_path(s,
with_time_reversal=True,
reference_distance=0.025,
recipe='hpkot',
threshold=1.e-7)
self.assertTrue(retdict['has_inversion_symmetry'])
self.assertFalse(retdict['augmented_path'])
self.assertAlmostEqual(retdict['volume_original_wrt_prim'], 1.0)
self.assertEqual(retdict['segments'], [(0, 31), (30, 61), (60, 104),
(103, 123), (122, 153),
(152, 183), (182, 226),
(226, 246), (246, 266)])
ret_s = retdict['primitive_structure']
ret_k = retdict['explicit_kpoints']
self.assertEqual(ret_k.labels, [(0, 'GAMMA'), (30, 'X'), (60, 'M'),
(103, 'GAMMA'), (122, 'Z'), (152, 'R'),
(182, 'A'), (225, 'Z'), (226, 'X'),
(245, 'R'), (246, 'M'), (265, 'A')])
kpts = ret_k.get_kpoints(cartesian=False)
highsympoints_relcoords = [kpts[idx] for idx, label in ret_k.labels]
self.assertAlmostEqual(
np.sum(
np.abs(
np.array([
[0., 0., 0.], # Gamma
[0., 0.5, 0.], # X
[0.5, 0.5, 0.], # M
[0., 0., 0.], # Gamma
[0., 0., 0.5], # Z
[0., 0.5, 0.5], # R
[0.5, 0.5, 0.5], # A
[0., 0., 0.5], # Z
[0., 0.5, 0.], # X
[0., 0.5, 0.5], # R
[0.5, 0.5, 0.], # M
[0.5, 0.5, 0.5], # A
]) - np.array(highsympoints_relcoords))),
0.)
# The primitive structure should be the same as the one I input
self.assertAlmostEqual(
np.sum(np.abs(np.array(s.cell) - np.array(ret_s.cell))), 0.)
self.assertEqual([_.kind_name for _ in s.sites],
[_.kind_name for _ in ret_s.sites])
self.assertEqual(
np.sum(
np.abs(
np.array([_.position for _ in s.sites]) -
np.array([_.position for _ in ret_s.sites]))), 0.)
def test_simple(self):
import numpy as np
from aiida.orm import DataFactory
s = DataFactory('structure')(cell=[[4, 0, 0], [0, 4, 0], [0, 0, 6]])
s.append_atom(symbols='Ba', position=[0, 0, 0])
s.append_atom(symbols='Ti', position=[2, 2, 3])
s.append_atom(symbols='O', position=[2, 2, 0])
s.append_atom(symbols='O', position=[2, 0, 3])
s.append_atom(symbols='O', position=[0, 2, 3])
retdict = get_path(s,
with_time_reversal=True,
reference_distance=0.025,
recipe='hpkot',
threshold=1.e-7)
self.assertTrue(retdict['has_inversion_symmetry'])
self.assertFalse(retdict['augmented_path'])
self.assertAlmostEqual(retdict['volume_original_wrt_prim'], 1.0)
self.assertAlmostEqual(retdict['volume_original_wrt_conv'], 1.0)
self.assertEqual(retdict['bravais_lattice'], 'tP')
self.assertEqual(retdict['bravais_lattice_extended'], 'tP1')
self.assertEqual(retdict['path'], [('GAMMA', 'X'), ('X', 'M'),
('M', 'GAMMA'), ('GAMMA', 'Z'),
('Z', 'R'), ('R', 'A'), ('A', 'Z'),
('X', 'R'), ('M', 'A')])
self.assertEqual(
retdict['point_coords'], {
'A': [0.5, 0.5, 0.5],
'M': [0.5, 0.5, 0.0],
'R': [0.0, 0.5, 0.5],
'X': [0.0, 0.5, 0.0],
'Z': [0.0, 0.0, 0.5],
'GAMMA': [0.0, 0.0, 0.0]
})
self.assertAlmostEqual(
np.sum(
np.abs(
np.array(
retdict['inverse_primitive_transformation_matrix']) -
np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]]))), 0.)
ret_prims = retdict['primitive_structure']
ret_convs = retdict['conv_structure']
# The primitive structure should be the same as the one I input
self.assertAlmostEqual(
np.sum(np.abs(np.array(s.cell) - np.array(ret_prims.cell))), 0.)
self.assertEqual([_.kind_name for _ in s.sites],
[_.kind_name for _ in ret_prims.sites])
self.assertEqual(
np.sum(
np.abs(
np.array([_.position for _ in s.sites]) -
np.array([_.position for _ in ret_prims.sites]))), 0.)
# Also the conventional structure should be the same as the one I input
self.assertAlmostEqual(
np.sum(np.abs(np.array(s.cell) - np.array(ret_convs.cell))), 0.)
self.assertEqual([_.kind_name for _ in s.sites],
[_.kind_name for _ in ret_convs.sites])
self.assertEqual(
np.sum(
np.abs(
np.array([_.position for _ in s.sites]) -
np.array([_.position for _ in ret_convs.sites]))), 0.)
class Vasp5CalcTest(AiidaTestCase):
'''
Test Case for
py:class:`~aiida.orm.calculation.job.vasp.vasp5.Vasp5Calculation`
'''
def setUp(self):
self.calc = CalculationFactory('vasp.vasp5')()
Common.import_paw()
larray = np.array([[0, .5, .5],
[.5, 0, .5],
[.5, .5, 0]])
alat = 6.058
self.structure = DataFactory('structure')(cell=larray*alat)
self.structure.append_atom(position=[0, 0, 0], symbols='In')
self.structure.append_atom(position=[.25, .25, .25], symbols='As')
cifpath = realpath(join(dirname(__file__),
'data', 'EntryWithCollCode43360.cif'))
self.cif = DataFactory('cif').get_or_create(cifpath)[0]
def test_inputs(self):
self.assertTrue(hasattr(self.calc, 'use_code'))
self.assertTrue(hasattr(self.calc, 'use_settings'))
self.assertTrue(hasattr(self.calc, 'use_structure'))
self.assertTrue(hasattr(self.calc, 'use_paw'))
self.assertTrue(hasattr(self.calc, 'use_kpoints'))
self.assertTrue(hasattr(self.calc, 'use_charge_density'))
self.assertTrue(hasattr(self.calc, 'use_wavefunctions'))
def test_internal_params(self):
self.assertTrue(self.calc.get_parser_name())
def test_settings_property(self):
self.calc.use_settings(self.calc.new_settings(dict={'A': 0}))
self.assertEqual(self.calc._settings, {'a': 0})
def test_write_incar(self):
'''
write out an INCAR tag to a tempfile and check wether
it was written correctly
'''
inc = self.calc.new_settings(dict={'system': 'InAs'})
dst = tempfile.mkstemp()[1]
self.calc.use_settings(inc)
self.calc.write_incar({}, dst)
with open(dst, 'r') as incar:
self.assertEqual(incar.read().strip(), 'SYSTEM = InAs')
def test_write_potcar(self):
'''
concatenate two paws into a tmp POTCAR and check wether
each is contained in the result
'''
self.calc.use_settings(self.calc.new_settings(dict={'System': 'Test'}))
self.calc.use_structure(self.structure)
self.calc.use_paw(
self.calc.load_paw(family='TEST', symbol='In_d'), kind='In')
self.calc.use_paw(
self.calc.load_paw(family='TEST', symbol='As'), kind='As')
dst = tempfile.mkstemp()[1]
self.calc.write_potcar(self.calc.get_inputs_dict(), dst)
with open(dst, 'r') as potcar:
x = potcar.read()
with open(self.calc.inp.paw_In.potcar, 'r') as paw_In:
a = paw_In.read()
self.assertIn(a, x)
with open(self.calc.inp.paw_As.potcar, 'r') as paw_As:
b = paw_As.read()
self.assertIn(b, x)
def test_write_poscar(self):
'''
feed a structure into calc and write it to a POSCAR temp file
check for nonemptiness of the file
'''
self.calc.use_structure(self.structure)
dst = tempfile.mkstemp()[1]
self.calc.write_poscar({}, dst)
with open(dst, 'r') as poscar:
self.assertTrue(poscar.read())
def test_write_poscar_cif(self):
'''
feed a cif file into calc and write it to a POSCAR temp file
make sure the file is not empty
'''
self.calc.use_structure(self.cif)
dst = tempfile.mkstemp()[1]
self.calc.write_poscar({}, dst)
with open(dst, 'r') as poscar:
self.assertTrue(poscar.read())
def test_write_kpoints(self):
'''
feed kpoints into calc and write to KPOINTS temp file
verify the file is not empty
'''
kp = self.calc.new_kpoints()
kp.set_kpoints_mesh([4, 4, 4])
self.calc.use_kpoints(kp)
self.calc.use_settings(self.calc.new_settings())
dst = tempfile.mkstemp()[1]
self.calc.write_kpoints(self.calc.get_inputs_dict(), dst)
with open(dst, 'r') as kpoints:
self.assertTrue(kpoints.read())
def test_need_kp_false(self):
self.calc.use_settings(
self.calc.new_settings(dict={'kspacing': 0.5, 'kgamma': True}))
self.assertFalse(self.calc._need_kp())
def test_need_kp_true(self):
self.calc.use_settings(self.calc.new_settings())
self.assertTrue(self.calc._need_kp())
def test_need_chgd_none(self):
self.calc.use_settings(self.calc.new_settings())
self.assertFalse(self.calc._need_chgd())
def test_need_chgd_icharg(self):
for i in [0, 2, 4, 10, 12]:
self.calc.use_settings(
self.calc.new_settings(dict={'icharg': i}))
self.assertFalse(self.calc._need_chgd())
for i in [1, 11]:
self.calc.use_settings(
self.calc.new_settings(dict={'icharg': i}))
self.assertTrue(self.calc._need_chgd())
def test_need_wfn_none(self):
self.calc.use_settings(self.calc.new_settings())
self.assertFalse(self.calc._need_wfn())
self.calc.use_wavefunctions(self.calc.new_wavefunctions())
self.assertTrue(self.calc._need_wfn())
def test_need_wfn_istart(self):
self.calc.use_settings(
self.calc.new_settings(dict={'istart': 0}))
self.assertFalse(self.calc._need_wfn())
for i in [1, 2, 3]:
self.calc.use_settings(
self.calc.new_settings(dict={'istart': i}))
self.assertTrue(self.calc._need_wfn(),
msg='_need_wfn not True for istart=%s' % i)
def test_get_paw_linkname(self):
self.assertEqual(self.calc._get_paw_linkname('In'), 'paw_In')
def test_Paw(self):
self.assertIs(self.calc.Paw, DataFactory('vasp.paw'))
def test_load_paw(self):
paw_A = self.calc.load_paw(family='TEST', symbol='As')
paw_B = self.calc.Paw.load_paw(family='TEST', symbol='As')[0]
self.assertEqual(paw_A.pk, paw_B.pk)
def test_new_setting(self):
self.assertIsInstance(self.calc.new_settings(),
DataFactory('parameter'))
def test_new_structure(self):
self.assertIsInstance(self.calc.new_structure(),
DataFactory('structure'))
def test_new_kpoints(self):
self.assertIsInstance(self.calc.new_kpoints(),
DataFactory('array.kpoints'))
def test_new_charge_density(self):
self.assertIsInstance(self.calc.new_charge_density(),
DataFactory('vasp.chargedensity'))
def test_new_wavefunctions(self):
self.assertIsInstance(self.calc.new_wavefunctions(),
DataFactory('vasp.wavefun'))
def test_simple(self):
import numpy as np
from aiida.orm import DataFactory
structure = DataFactory('structure')(
cell=[[4, 0, 0], [0, 4, 0], [0, 0, 6]])
structure.append_atom(symbols='Ba', position=[0, 0, 0])
structure.append_atom(symbols='Ti', position=[2, 2, 3])
structure.append_atom(symbols='O', position=[2, 2, 0])
structure.append_atom(symbols='O', position=[2, 0, 3])
structure.append_atom(symbols='O', position=[0, 2, 3])
params = DataFactory('parameter')(dict={
'with_time_reversal': True,
'recipe': 'hpkot',
'threshold': 1.e-7
})
return_value = get_path(structure, params)
retdict = return_value['seekpath_parameters'].get_dict()
self.assertTrue(retdict['has_inversion_symmetry'])
self.assertFalse(retdict['augmented_path'])
self.assertAlmostEqual(retdict['volume_original_wrt_prim'], 1.0)
self.assertAlmostEqual(retdict['volume_original_wrt_conv'], 1.0)
self.assertEqual(retdict['bravais_lattice'], 'tP')
self.assertEqual(retdict['bravais_lattice_extended'], 'tP1')
self.assertEqual(
to_list_of_lists(retdict['path']),
[['GAMMA', 'X'], ['X', 'M'], ['M', 'GAMMA'], ['GAMMA', 'Z'],
['Z', 'R'], ['R', 'A'], ['A', 'Z'], ['X', 'R'], ['M', 'A']])
self.assertEqual(
retdict['point_coords'], {
'A': [0.5, 0.5, 0.5],
'M': [0.5, 0.5, 0.0],
'R': [0.0, 0.5, 0.5],
'X': [0.0, 0.5, 0.0],
'Z': [0.0, 0.0, 0.5],
'GAMMA': [0.0, 0.0, 0.0]
})
self.assertAlmostEqual(
np.sum(
np.abs(
np.array(
retdict['inverse_primitive_transformation_matrix']) -
np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]]))), 0.)
ret_prims = return_value['primitive_structure']
ret_convs = return_value['conv_structure']
# The primitive structure should be the same as the one I input
self.assertAlmostEqual(
np.sum(np.abs(np.array(structure.cell) -
np.array(ret_prims.cell))), 0.)
self.assertEqual([_.kind_name for _ in structure.sites],
[_.kind_name for _ in ret_prims.sites])
self.assertEqual(
np.sum(
np.abs(
np.array([_.position for _ in structure.sites]) -
np.array([_.position for _ in ret_prims.sites]))), 0.)
# Also the conventional structure should be the same as the one I input
self.assertAlmostEqual(
np.sum(np.abs(np.array(structure.cell) -
np.array(ret_convs.cell))), 0.)
self.assertEqual([_.kind_name for _ in structure.sites],
[_.kind_name for _ in ret_convs.sites])
self.assertEqual(
np.sum(
np.abs(
np.array([_.position for _ in structure.sites]) -
np.array([_.position for _ in ret_convs.sites]))), 0.)
def test_simple(self):
import numpy as np
from aiida.orm import DataFactory
structure = DataFactory('structure')(
cell=[[4, 0, 0], [0, 4, 0], [0, 0, 6]])
structure.append_atom(symbols='Ba', position=[0, 0, 0])
structure.append_atom(symbols='Ti', position=[2, 2, 3])
structure.append_atom(symbols='O', position=[2, 2, 0])
structure.append_atom(symbols='O', position=[2, 0, 3])
structure.append_atom(symbols='O', position=[0, 2, 3])
params = DataFactory('parameter')(dict={
'with_time_reversal': True,
'reference_distance': 0.025,
'recipe': 'hpkot',
'threshold': 1.e-7
})
return_value = get_explicit_k_path(structure, params)
retdict = return_value['seekpath_parameters'].get_dict()
self.assertTrue(retdict['has_inversion_symmetry'])
self.assertFalse(retdict['augmented_path'])
self.assertAlmostEqual(retdict['volume_original_wrt_prim'], 1.0)
self.assertEqual(to_list_of_lists(retdict['explicit_segments']),
[[0, 31], [30, 61], [60, 104], [103, 123], [122, 153],
[152, 183], [182, 226], [226, 246], [246, 266]])
ret_k = return_value['explicit_kpoints']
self.assertEqual(to_list_of_lists(ret_k.labels),
[[0, 'GAMMA'], [30, 'X'], [60, 'M'], [103, 'GAMMA'],
[122, 'Z'], [152, 'R'], [182, 'A'], [225, 'Z'],
[226, 'X'], [245, 'R'], [246, 'M'], [265, 'A']])
kpts = ret_k.get_kpoints(cartesian=False)
highsympoints_relcoords = [kpts[idx] for idx, label in ret_k.labels]
self.assertAlmostEqual(
np.sum(
np.abs(
np.array([
[0., 0., 0.], # Gamma
[0., 0.5, 0.], # X
[0.5, 0.5, 0.], # M
[0., 0., 0.], # Gamma
[0., 0., 0.5], # Z
[0., 0.5, 0.5], # R
[0.5, 0.5, 0.5], # A
[0., 0., 0.5], # Z
[0., 0.5, 0.], # X
[0., 0.5, 0.5], # R
[0.5, 0.5, 0.], # M
[0.5, 0.5, 0.5], # A
]) - np.array(highsympoints_relcoords))),
0.)
ret_prims = return_value['primitive_structure']
ret_convs = return_value['conv_structure']
# The primitive structure should be the same as the one I input
self.assertAlmostEqual(
np.sum(np.abs(np.array(structure.cell) -
np.array(ret_prims.cell))), 0.)
self.assertEqual([_.kind_name for _ in structure.sites],
[_.kind_name for _ in ret_prims.sites])
self.assertEqual(
np.sum(
np.abs(
np.array([_.position for _ in structure.sites]) -
np.array([_.position for _ in ret_prims.sites]))), 0.)
# Also the conventional structure should be the same as the one I input
self.assertAlmostEqual(
np.sum(np.abs(np.array(structure.cell) -
np.array(ret_convs.cell))), 0.)
self.assertEqual([_.kind_name for _ in structure.sites],
[_.kind_name for _ in ret_convs.sites])
self.assertEqual(
np.sum(
np.abs(
np.array([_.position for _ in structure.sites]) -
np.array([_.position for _ in ret_convs.sites]))), 0.)
