def test_store_and_load_potcar_data(interactive_potcar_file):
from aiida.orm import load_node
# generate arbitrary potential and process it using the potcar parser
potential_contents = "\n".join([
"functional Si 01Jan1000",
"parameters from PSCTR are:",
"VRHFIN =Si: s100p100d100",
"TITEL = functional Si 01Jan1000"
"END of PSCTR-controll parameters",
])
interactive_potcar_file.open("POTCAR")
interactive_potcar_file.write(potential_contents)
path_to_potcar = pathlib.Path(interactive_potcar_file.filepath)
potcar_file_node = VaspPotcarFile.add_potential(path_to_potcar,
name='Si',
functional='pbe')
potcar_file_node.store()
# create VaspPotcarData instance associated with the stored potential
potcar_data_set = VaspPotcarData(name='Si',
version=10000101,
functional='pbe')
uuid = potcar_data_set.store().uuid
# load the data node and compare stored contents
potcar_data_get = load_node(uuid)
assert potcar_data_get.name == potcar_file_node.name
assert potcar_data_get.version == potcar_file_node.version
assert potcar_data_get.functional == potcar_file_node.functional
assert potcar_data_get.element == potcar_file_node.element
assert potcar_data_get.hash == potcar_file_node.hash
assert potcar_data_get.filenode_uuid == potcar_file_node.uuid
def test_potcar_from_linklist(with_pbe_potcars, multi_component_structure):
from aiida_cusp.data.inputs.vasp_potcar import VaspPotcarFile
from aiida_cusp.data.inputs.vasp_poscar import VaspPoscarData
poscar = VaspPoscarData(structure=multi_component_structure)
potmap = VaspPotcarData.from_structure(multi_component_structure, 'pbe')
complete_potcar = VaspPotcarData.potcar_from_linklist(poscar, potmap)
# build the expected potcar
potcar_contents = []
for symbol in poscar.get_poscar().site_symbols:
potcar_file = VaspPotcarFile.from_tags(name=symbol)[0]
potcar_contents.append(potcar_file.get_content())
expected_potcar_contents = "\n".join(potcar_contents) + "\n"
assert str(complete_potcar) == expected_potcar_contents
def test_potcar_from_linklist_raises_on_missing(symbol, with_pbe_potcars,
multi_component_structure):
from aiida_cusp.data.inputs.vasp_potcar import VaspPotcarData
from aiida_cusp.utils.exceptions import VaspPotcarDataError
poscar = VaspPoscarData(structure=multi_component_structure)
potmap = VaspPotcarData.from_structure(multi_component_structure, 'pbe')
# pop an arbitrary potential from the map and check that the call to
# potcar_from_linklist() fails for the given structure
potmap.pop(symbol)
expected_error = ("Found no potential in passed potential-element map for "
"site symbol '{}'".format(symbol))
with pytest.raises(VaspPotcarDataError) as exception:
_ = VaspPotcarData.potcar_from_linklist(poscar, potmap)
assert str(exception.value) == expected_error
def test_load_potential_file_node_properties_match(interactive_potcar_file,
change_prop):
interactive_potcar_file.open("POTCAR")
path = pathlib.Path(interactive_potcar_file.filepath).absolute()
args = ['Si', 'Si', 10000101, 'pbe', 'hash']
file_node = VaspPotcarFile(path, *args).store()
# create VaspPotcarData instance associated with the stored potential and
# change one of the properties
potcar_data = VaspPotcarData(name='Si', version=10000101, functional='pbe')
potcar_data.update_dict({change_prop: None})
# try loading the potential file which should raise an attribute error
# due to the mismatch in the stored potential properties
with pytest.raises(AssertionError) as exception:
potcar_file_get = potcar_data.load_potential_file_node()
def test_load_potential_file_node_from_uuid(interactive_potcar_file):
# generate arbitrary potential and process it using the potcar parser
interactive_potcar_file.open("POTCAR")
path = pathlib.Path(interactive_potcar_file.filepath).absolute()
args = ['Si', 'Si', 10000101, 'pbe', 'hash']
potcar_file_set = VaspPotcarFile(path, *args).store()
# create VaspPotcarData instance associated with the stored potential
potcar_data = VaspPotcarData(name='Si', version=10000101, functional='pbe')
# load node from potcar_data instance
potcar_file_get = potcar_data.load_potential_file_node()
assert potcar_file_get.uuid == potcar_file_set.uuid
assert potcar_file_get.hash == potcar_file_set.hash
assert potcar_file_get.element == potcar_file_set.element
assert potcar_file_get.functional == potcar_file_set.functional
assert potcar_file_get.name == potcar_file_set.name
def test_init_from_tags_raises_on_missing_node():
# try to initialize from non-existent potential
with pytest.raises(VaspPotcarDataError) as exception:
potcar_data = VaspPotcarData(name='Si',
version=10000101,
functional='pbe')
assert "Unable to initialize VaspPotcarData" in str(exception.value)
def test_init_from_tags_rases_on_missing_parameters(missing_prop):
# complete parameter list
kwargs = {'name': 'Si', 'version': 10000101, 'functional': 'pbe'}
kwargs.update({missing_prop: None})
expected_error = "Missing non-optional argument '{}'".format(missing_prop)
with pytest.raises(VaspPotcarDataError) as exception:
potcar_data = VaspPotcarData(**kwargs)
assert str(exception.value) == expected_error
def test_load_potential_file_node_from_hash(interactive_potcar_file):
# generate arbitrary potential and process it using the potcar parser
interactive_potcar_file.open("POTCAR")
path = pathlib.Path(interactive_potcar_file.filepath).absolute()
args = ['Si', 'Si', 10000101, 'pbe', 'hash']
potcar_file_set = VaspPotcarFile(path, *args).store()
# create VaspPotcarData instance associated with the stored potential but
# change the associated uuid
potcar_data = VaspPotcarData(name='Si', version=10000101, functional='pbe')
potcar_data.update_dict({'filenode_uuid': "changed_uuid"})
assert potcar_data.filenode_uuid == "changed_uuid"
# try loading the potential using the stored hash instead of the uuid
potcar_file_get = potcar_data.load_potential_file_node()
assert potcar_file_get.uuid == potcar_file_set.uuid
assert potcar_file_get.hash == potcar_file_set.hash
assert potcar_file_get.element == potcar_file_set.element
assert potcar_file_get.functional == potcar_file_set.functional
assert potcar_file_get.name == potcar_file_set.name
def test_from_structure_classmethod_single(name, interactive_potcar_file,
version, functional, structure_type,
minimal_pymatgen_structure):
# create non-ordered structures of different types
supercell = minimal_pymatgen_structure * (2, 2, 2)
if structure_type == 'pymatgen':
structure = supercell
elif structure_type == 'aiida':
structure = StructureData(pymatgen_structure=supercell)
elif structure_type == 'poscar':
structure = Poscar(supercell)
elif structure_type == 'aiida_cusp_poscar':
structure = VaspPoscarData(structure=supercell)
# populate database with potentials
potcar_args = [
['H', 'H', 10000101, 'pbe', 'hash1'],
['H', 'H', 10000102, 'pbe', 'hash2'],
['H_pv', 'H', 10000101, 'pbe', 'hash3'],
['H_pv', 'H', 10000102, 'pbe', 'hash4'],
['H', 'H', 10000101, 'pw91', 'hash5'],
['H', 'H', 10000102, 'pw91', 'hash6'],
['H_pv', 'H', 10000101, 'pw91', 'hash7'],
['H_pv', 'H', 10000102, 'pw91', 'hash8'],
]
interactive_potcar_file.open("POTCAR")
path = pathlib.Path(interactive_potcar_file.filepath).absolute()
for args in potcar_args:
VaspPotcarFile(path, *args).store()
# setup alternative (non-default) potcar parameters
potcar_params = {'H': {}}
if name is not None:
potcar_params['H'].update({'name': name})
if version is not None:
potcar_params['H'].update({'version': version})
if not potcar_params['H']:
potcar_params = {}
# create the element-potential map
potential_map = VaspPotcarData.from_structure(structure,
functional,
potcar_params=potcar_params)
# check that the map contains only a single entry
assert len(potential_map.keys()) == 1
assert list(potential_map.keys()) == ['H']
# assert potential properties match the wanted ones
expected_name = name or 'H'
expected_version = version or 10000102
assert potential_map['H'].name == expected_name
assert potential_map['H'].version == expected_version
assert potential_map['H'].functional == functional.lower()
# check that we indeed return a VaspPotcarData instance and nothing else
assert isinstance(potential_map['H'], VaspPotcarData) is True
def test_load_potential_file_raises_on_undiscoverable(interactive_potcar_file):
# generate arbitrary potential and process it using the potcar parser
interactive_potcar_file.open("POTCAR")
path = pathlib.Path(interactive_potcar_file.filepath).absolute()
args = ['Si', 'Si', 10000101, 'pbe', 'hash']
potcar_file_set = VaspPotcarFile(path, *args).store()
# create VaspPotcarData instance associated with the stored potential but
# change uuid and hash to make the potentials undiscoverable
potcar_data = VaspPotcarData(name='Si', version=10000101, functional='pbe')
potcar_data.update_dict({'filenode_uuid': "changed_uuid"})
potcar_data.update_dict({'hash': "changed_hash"})
# try loading the potential using the stored hash instead of the uuid
with pytest.raises(VaspPotcarDataError) as exception:
potcar_file_get = potcar_data.load_potential_file_node()
assert "Unable to discover associated potential" in str(exception.value)
def test_from_structure_classmethod_multi(with_pbe_potcars, structure_type,
multi_component_structure):
from aiida_cusp.data.inputs.vasp_poscar import VaspPoscarData
if structure_type == 'pymatgen':
structure = multi_component_structure
elif structure_type == 'aiida':
structure = StructureData(pymatgen_structure=multi_component_structure)
elif structure_type == 'poscar':
structure = Poscar(multi_component_structure)
elif structure_type == 'aiida_cusp_poscar':
structure = VaspPoscarData(structure=multi_component_structure)
# generate potental map using the default potential settings (i.e.
# name == element, version == latest)
potential_map = VaspPotcarData.from_structure(structure, 'pbe')
all_elements = ['Li', 'S', 'P', 'Br']
def_elements = potential_map.keys()
assert set(def_elements) == set(all_elements)
# check potential names and functionals match
for element in all_elements:
assert potential_map[element].name == element
assert potential_map[element].functional == 'pbe'
def test_potcar_props_from_name_raises(inputlist, expected_error):
from aiida_cusp.data import VaspPotcarData
from aiida_cusp.utils.exceptions import VaspPotcarDataError
with pytest.raises(VaspPotcarDataError) as exception:
_ = VaspPotcarData.potcar_props_from_name_list(inputlist)
assert expected_error in str(exception.value)
def test_potcar_props_from_name_list(element, potential_name):
from aiida_cusp.data import VaspPotcarData
potcar_name_list = [potential_name]
potcar_props = VaspPotcarData.potcar_props_from_name_list(potcar_name_list)
assert potcar_props[element]['name'] == potential_name