def parse(**extra_settings):
"""Run the parser using default settings updated with extra_settings."""
load_dbenv_if_not_loaded()
from aiida.orm import CalculationFactory, DataFactory
from aiida_vasp.parsers.vasp import VaspParser
calc = CalculationFactory('vasp.vasp')()
settings_dict = {
'parser_settings': {
'add_bands': True,
'output_params': ['fermi_level']
}
}
settings_dict.update(extra_settings)
calc.use_settings(DataFactory('parameter')(dict=settings_dict))
parser = VaspParser(calc=calc)
retrieved = DataFactory('folder')()
fldr = "basic"
if "folder" in extra_settings:
fldr = extra_settings["folder"]
xml_file_path = xml_path(fldr)
tmp_file_path = str(tmpdir.join('vasprun.xml'))
#tmp_file_path = os.path.realpath(os.path.join(
# __file__, '../../../test_data/tmp/vasprun.xml'))
xml_truncate(request.param, xml_file_path, tmp_file_path)
retrieved.add_path(tmp_file_path, '')
success, nodes = parser.parse_with_retrieved({'retrieved': retrieved})
nodes = dict(nodes)
return success, nodes
def wannrun(self):
params = self.get_parameters()
amnstep = self.get_attributes()['amnstep']
prev = self.get_step_calculations(self.amnrun)
amncalc = prev.get(uuid=amnstep['uuid'])
self.append_to_report('{}: retrieved amn calculation'.format(
params.get('name')))
calc = CalculationFactory('vasp.wannier')()
code = Code.get_from_string(params['wannier_x'])
calc.use_code(code)
calc.set_computer(code.get_computer())
calc.use_settings(amncalc.inp.wannier_settings)
calc.use_data(amncalc.out.wannier_data)
calc.label = params.get('name') + ': wannier run'
calc.set_resources({'num_machines': 1})
calc.set_queue_name(amncalc.get_queue_name())
calc.description = calc.label
calc.store_all()
calc.set_extras({'experiment': 'tight-binding'})
self.group.add_nodes(calc)
self.attach_calculation(calc)
self.add_result('wannier_run', calc)
self.append_to_report(
'{}: starting wannier run, PK={}, uuid={}'.format(
params.get('name'), calc.pk, calc.uuid))
self.add_attributes({'wannstep': {'pk': calc.pk, 'uuid': calc.uuid}})
self.next(self.exit)
def parse(**extra_settings):
"""Run the parser using default settings updated with extra_settings."""
from aiida.orm import CalculationFactory, DataFactory
calc = CalculationFactory('vasp.vasp')()
settings_dict = {'pymatgen_parser': {'parse_potcar_file': False, 'exception_on_bad_xml': request.param}}
settings_dict.update(extra_settings)
calc.use_settings(DataFactory('parameter')(dict=settings_dict))
parser = PymatgenParser(calc=calc)
retrieved = DataFactory('folder')()
retrieved.add_path(vasprun_path, '')
success, nodes = parser.parse_with_retrieved({'retrieved': retrieved})
nodes = dict(nodes)
return success, nodes
def get_wannier_calc(self, win, wdat):
from aiida.orm import CalculationFactory, Code
params = self.get_parameters()
calc = CalculationFactory('vasp.wannier')()
code = Code.get_from_string(params['wannier_code'])
calc.use_code(code)
calc.set_computer(code.get_computer())
calc.set_resources(params['resources'])
queue = params.get('queue') or params.get('queue')
calc.set_queue_name(queue)
calc.use_settings(win)
calc.use_data(wdat)
calc.label = params.get('label')
calc.description = params.get('description')
return calc
def parse_nac(aiida_env):
"""Give the parsing result of a retrieved NAC calculation (emulated)."""
from aiida.orm import CalculationFactory, DataFactory
calc = CalculationFactory('vasp.vasp')()
calc.use_settings(DataFactory('parameter')(dict={'pymatgen_parser': {'parse_potcar_file': False, 'exception_on_bad_xml': False}}))
parser = PymatgenParser(calc=calc)
retrieved = DataFactory('folder')()
retrieved.add_path(data_path('born_effective_charge', 'vasprun.xml'), '')
retrieved.add_path(data_path('born_effective_charge', 'OUTCAR'), '')
def parse():
success, nodes = parser.parse_with_retrieved({'retrieved': retrieved})
nodes = dict(nodes)
return success, nodes
return parse
def run_wswannier():
input_archive = get_input_archive()
code = Code.get_from_string('Wannier90_2.1.0')
calc = CalculationFactory('vasp.wswannier')()
calc.use_code(code)
# Monch
calc.set_resources(dict(num_machines=1, tot_num_mpiprocs=1))
calc.set_computer(Computer.get('Monch'))
calc.set_queue_name('express_compute')
calc.use_data(input_archive)
# hard-code parameters for InSb test
calc.use_settings(
ParameterData(dict=dict(
num_wann=14,
num_bands=36,
dis_num_iter=1000,
num_iter=0,
dis_win_min=-4.5,
dis_win_max=16.,
dis_froz_min=-4.,
dis_froz_max=6.5,
write_hr=True,
use_ws_distance=True,
write_xyz=True,
write_tb=True,
projections=[['In : s; px; py; pz'], ['Sb : px; py; pz']],
spinors=True,
unit_cell_cart=[[0., 3.2395, 3.2395], [3.2395, 0., 3.2395],
[3.2395, 3.2395, 0.]],
bands_plot=True,
atoms_cart=[['In', 0., 0., 0.], ['Sb', 1.61975, 1.61975, 1.61975]],
mp_grid='6 6 6',
kpoints=[
list(reversed(x)) for x in itertools.
product((0., 1 / 6, 2 / 6, 0.5, -2 / 6, -1 / 6), repeat=3)
],
kpoint_path=[
['G', 0, 0, 0, 'L', 0.5, 0.5, 0.5],
])))
calc.store_all()
calc.submit()
print('Submitted calculation', calc.pk)
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'))