def simple(pot_family, import_from, queue, code, computer, no_import):
load_dbenv_if_not_loaded()
from aiida.orm import CalculationFactory, Code
if not no_import:
click.echo('importing POTCAR files...')
with cli_spinner():
import_pots(import_from, pot_family)
pot_cls = get_data_cls('vasp.potcar')
pot_si = pot_cls.find_one(family=pot_family, full_name='Si')
vasp_calc = CalculationFactory('vasp.vasp')()
vasp_calc.use_structure(create_structure_Si())
vasp_calc.use_kpoints(create_kpoints())
vasp_calc.use_parameters(create_params_simple())
code = Code.get_from_string('{}@{}'.format(code, computer))
vasp_calc.use_code(code)
vasp_calc.use_potential(pot_si, 'Si')
vasp_calc.set_computer(code.get_computer())
vasp_calc.set_queue_name(queue)
vasp_calc.set_resources({
'num_machines': 1,
'num_mpiprocs_per_machine': 20
})
vasp_calc.label = 'Test VASP run'
vasp_calc.store_all()
vasp_calc.submit()
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'))
