def get_pseudo(self, element):
"""Return the `UpfData` for the given element.
:param element: the element for which to return the corresponding `UpfData` node.
:return: `UpfData` instance if it exists
:raises ValueError: if the family does not contain a `UpfData` for the given element
"""
try:
pseudo = self.pseudos[element]
except KeyError:
builder = QueryBuilder().append(
SsspFamily, filters={'id': self.pk}, tag='group').append(
self._node_types, filters={'attributes.element': element}, with_group='group') # yapf:disable
try:
pseudo = builder.one()[0]
except exceptions.MultipleObjectsError:
raise RuntimeError(
'family `{}` contains multiple pseudos for `{}`'.format(
self.label, element))
except exceptions.NotExistent:
raise ValueError(
'family `{}` does not contain pseudo for element `{}`'.
format(self.label, element))
else:
self.pseudos[element] = pseudo
return pseudo
def get_data_aiida(cif_uuid, plot_info):
"""Query the AiiDA database"""
from figure.aiida import load_profile
from aiida.orm import QueryBuilder, Dict, CifData
load_profile()
qb = QueryBuilder()
qb.append(CifData,
filters={'uuid': {
'==': cif_uuid
}},
tag='cifs',
project='*')
qb.append(
Dict,
descendant_of='cifs',
project='*',
)
nresults = qb.count()
if nresults == 0:
plot_info.text = 'No matching COF found.'
return None
return qb.one()
def get_pseudo(self, element):
"""Return the pseudo potential for the given element.
:param element: the element for which to return the corresponding pseudo potential.
:return: pseudo potential instance if it exists
:raises ValueError: if the family does not contain a pseudo potential for the given element
"""
try:
pseudo = self.pseudos[element]
except KeyError:
builder = QueryBuilder()
builder.append(self.__class__, filters={'id': self.pk}, tag='group')
builder.append(self._pseudo_types, filters={'attributes.element': element}, with_group='group')
try:
pseudo = builder.one()[0]
except exceptions.MultipleObjectsError as exception:
raise RuntimeError(f'family `{self.label}` contains multiple pseudos for `{element}`') from exception
except exceptions.NotExistent as exception:
raise ValueError(
f'family `{self.label}` does not contain pseudo for element `{element}`'
) from exception
else:
self.pseudos[element] = pseudo
return pseudo
def get_basis(self, element):
"""Return the basis for the given element.
:param element: the element for which to return the corresponding basis.
:return: basis instance if it exists
:raises ValueError: if the basis set does not contain a basis for the given element
"""
try:
basis = self.bases[element]
except KeyError:
builder = QueryBuilder()
builder.append(self.__class__,
filters={'id': self.pk},
tag='group')
builder.append(self._basis_types,
filters={'attributes.element': element},
with_group='group')
try:
basis = builder.one()[0]
except exceptions.MultipleObjectsError as exception:
raise RuntimeError(
f'basis set `{self.label}` contains multiple bases for `{element}`'
) from exception
except exceptions.NotExistent as exception:
raise ValueError(
f'basis set `{self.label}` does not contain basis for element `{element}`'
) from exception
else:
self.bases[element] = basis
return basis
def get_code(entry_point,
executable,
computer=aiida_localhost,
label=None,
prepend_text=None,
append_text=None):
"""Get local code.
Sets up code for given entry point on given computer.
:param entry_point: Entry point of calculation plugin
:param executable: name of executable; will be searched for in local system PATH.
:param computer: (local) AiiDA computer
:param prepend_text: a string of code that will be put in the scheduler script before the execution of the code.
:param append_text: a string of code that will be put in the scheduler script after the execution of the code.
:return: the `Code` either retrieved from the database or created if it did not yet exist.
:rtype: :py:class:`aiida.orm.Code`
"""
from aiida.common import exceptions
from aiida.orm import Code, Computer, QueryBuilder
if label is None:
label = executable
builder = QueryBuilder().append(Computer,
filters={'uuid': computer.uuid},
tag='computer')
builder.append(Code,
filters={
'label': label,
'attributes.input_plugin': entry_point
},
with_computer='computer')
try:
code = builder.one()[0]
except (exceptions.MultipleObjectsError, exceptions.NotExistent):
code = None
else:
return code
executable_path = shutil.which(executable)
if not executable_path:
raise ValueError(
'The executable "{}" was not found in the $PATH.'.format(
executable))
code = Code(input_plugin_name=entry_point,
remote_computer_exec=[computer, executable_path])
code.label = label
code.description = label
if prepend_text is not None:
code.set_prepend_text(prepend_text)
if append_text is not None:
code.set_append_text(append_text)
return code.store()
def get_parameters_node(self):
"""Return the associated `SsspParameters` node if it exists.
:return: the associated `SsspParameters` node containing information like recommended cutoffs
:raises: `aiida.common.exceptions.NotExistent` if the family does not have associated parameters
"""
from aiida_sssp.data import SsspParameters
if self._parameters_node is None:
filters = {
'attributes.{}'.format(SsspParameters.KEY_FAMILY_UUID):
self.uuid
}
builder = QueryBuilder().append(SsspParameters, filters=filters)
self._parameters_node = builder.one()[0]
self._parameters = self._parameters_node.attributes
return self._parameters_node
