def get_upf_node(self, store=False):
"""
Creates an UPF node, that can be used in AiiDA workflow.
:return: :py:class:`aiida.orm.nodes.data.upf.UpfData` object
"""
from aiida.orm import UpfData
import tempfile
upfnode = None
# Prefixing with an ID in order to start file name with the name
# of the described element.
with tempfile.NamedTemporaryFile(mode='w+',
prefix=self.source['id']) as f:
f.write(self.contents)
f.flush()
upfnode = UpfData(file=f.name, source=self.source)
# Maintaining backwards-compatibility. Parameter 'store' should
# be removed in the future, as the new node can be stored later.
if store:
upfnode.store()
return upfnode
def upf_import(filename):
"""
Import a UPF pseudopotential from a file.
"""
from aiida.orm import UpfData
node, _ = UpfData.get_or_create(filename)
echo.echo_success('Imported: {}'.format(node))
def _generate_upf_data(element):
"""Return `UpfData` node."""
from aiida.orm import UpfData
filepath = os.path.join(filepath_tests, 'fixtures', 'pseudos', '{}.upf'.format(element))
with io.open(filepath, 'r') as handle:
upf = UpfData(file=handle.name)
return upf
def create_builder_from_file(input_folder, input_file_name, code, metadata, pseudo_folder_path=None, use_first=False):
"""Create a populated process builder for a `PwCalculation` from a standard QE input file and pseudo (upf) files
:param input_folder: the folder containing the input file
:type input_folder: aiida.common.folders.Folder or str
:param input_file_name: the name of the input file
:type input_file_name: str
:param code: the code associated with the calculation
:type code: aiida.orm.Code or str
:param metadata: metadata values for the calculation (e.g. resources)
:type metadata: dict
:param pseudo_folder_path: the folder containing the upf files (if None, then input_folder is used)
:type pseudo_folder_path: aiida.common.folders.Folder or str or None
:param use_first: passed to UpfData.get_or_create
:type use_first: bool
:raises NotImplementedError: if the structure is not ibrav=0
:return: a builder instance for PwCalculation
"""
PwCalculation = CalculationFactory('quantumespresso.pw')
builder = PwCalculation.get_builder()
builder.metadata = metadata
if isinstance(code, six.string_types):
code = Code.get_from_string(code)
builder.code = code
# read input_file
if isinstance(input_folder, six.string_types):
input_folder = Folder(input_folder)
with input_folder.open(input_file_name) as input_file:
parsed_file = PwInputFile(input_file)
builder.structure = parsed_file.get_structuredata()
builder.kpoints = parsed_file.get_kpointsdata()
if parsed_file.namelists['SYSTEM']['ibrav'] != 0:
raise NotImplementedError('Found ibrav != 0: `aiida-quantumespresso` currently only supports ibrav = 0.')
# Then, strip the namelist items that the plugin doesn't allow or sets later.
# NOTE: If any of the position or cell units are in alat or crystal
# units, that will be taken care of by the input parsing tools, and
# we are safe to fake that they were never there in the first place.
parameters_dict = copy.deepcopy(parsed_file.namelists)
for namelist, blocked_key in PwCalculation._blocked_keywords: # pylint: disable=protected-access
for key in list(parameters_dict[namelist].keys()):
# take into account that celldm and celldm(*) must be blocked
if re.sub('[(0-9)]', '', key) == blocked_key:
parameters_dict[namelist].pop(key, None)
builder.parameters = Dict(dict=parameters_dict)
# Get or create a UpfData node for the pseudopotentials used for the calculation.
pseudos_map = {}
if pseudo_folder_path is None:
pseudo_folder_path = input_folder
if isinstance(pseudo_folder_path, six.string_types):
pseudo_folder_path = Folder(pseudo_folder_path)
names = parsed_file.atomic_species['names']
pseudo_file_names = parsed_file.atomic_species['pseudo_file_names']
pseudo_file_map = {}
for name, fname in zip(names, pseudo_file_names):
if fname not in pseudo_file_map:
local_path = pseudo_folder_path.get_abs_path(fname)
upf_node, _ = UpfData.get_or_create(local_path, use_first=use_first, store_upf=False)
pseudo_file_map[fname] = upf_node
pseudos_map[name] = pseudo_file_map[fname]
builder.pseudos = pseudos_map
settings_dict = {}
if parsed_file.k_points['type'] == 'gamma':
settings_dict['gamma_only'] = True
# If there are any fixed coordinates (i.e. force modification) present in the input file, specify in settings
fixed_coords = parsed_file.atomic_positions['fixed_coords']
# Function ``any()`` only works for 1-dimensional lists so we have to call it twice manually.
if any((any(fc_xyz) for fc_xyz in fixed_coords)):
settings_dict['FIXED_COORDS'] = fixed_coords
if settings_dict:
builder.settings = settings_dict
return builder
def _generate_upf_data(element):
"""Return `UpfData` node."""
from aiida.orm import UpfData
return UpfData(file=os.path.abspath(pseudo_dir / f'{element}.upf'))