def WorkflowFactory(module):
"""
Return a suitable Workflow subclass.
"""
from aiida.orm.workflow import Workflow
return BaseFactory(module, Workflow, "aiida.workflows")
def ParserFactory(module):
"""
Return a suitable Parser subclass.
"""
from aiida.common.pluginloader import BaseFactory
return BaseFactory(module, Parser, "aiida.parsers.plugins")
def DataFactory(module):
"""
Return a suitable Data subclass.
"""
from aiida.orm.data import Data
return BaseFactory(module, Data, "aiida.orm.data")
def ParserFactory(module):
"""
Return a suitable Parser subclass.
"""
from aiida.common.pluginloader import BaseFactory
from aiida.common.exceptions import MissingPluginError
return BaseFactory(module, Parser, 'aiida.parsers.plugins')
def TcodExporterFactory(module):
"""
Return a suitable BaseTcodtranslator subclass.
"""
from aiida.common.pluginloader import BaseFactory
return BaseFactory(module, BaseTcodtranslator,
'aiida.tools.dbexporters.tcod_plugins')
def OrbitalFactory(module):
"""
Factory method that returns a suitable Orbital subclass.
:param module: a valid string recognized as a Orbital subclass
"""
from aiida.common.pluginloader import BaseFactory
return BaseFactory(module, Orbital, "aiida.common.orbital")
def SchedulerFactory(module):
"""
Used to load a suitable Scheduler subclass.
:param str module: a string with the module name
:return: the scheduler subclass contained in module 'module'
"""
from aiida.common.pluginloader import BaseFactory
return BaseFactory(module, Scheduler, "aiida.scheduler.plugins")
def TransportFactory(module):
"""
Used to return a suitable Transport subclass.
:param str module: name of the module containing the Transport subclass
:return: the transport subclass located in module 'module'
"""
from aiida.common.pluginloader import BaseFactory
return BaseFactory(module, Transport, "aiida.transport.plugins")
def CalculationFactory(module, from_abstract=False):
"""
Return a suitable JobCalculation subclass.
:param module: a valid string recognized as a Calculation plugin
:param from_abstract: A boolean. If False (default), actually look only
to subclasses to JobCalculation, not to the base Calculation class.
If True, check for valid strings for plugins of the Calculation base class.
"""
from aiida.orm.calculation import Calculation
from aiida.orm.calculation.job import JobCalculation
if from_abstract:
return BaseFactory(module, Calculation, "aiida.orm.calculation")
else:
return BaseFactory(module,
JobCalculation,
"aiida.orm.calculation.job",
suffix="Calculation")
def DbImporterFactory(pluginname):
"""
This function loads the correct DbImporter plugin class
"""
from aiida.common.pluginloader import BaseFactory
from aiida.tools.dbimporters.baseclasses import DbImporter
return BaseFactory(pluginname, DbImporter,
"aiida.tools.dbimporters.plugins")
raise NotImplementedError
def ParserInstructionFactory(module):
"""
Return a suitable VASP parser utility function.
"""
from aiida.common.pluginloader import BaseFactory
from aiida.parsers.plugins.vasp.instruction import BaseInstruction
try:
return BaseFactory(module,
BaseInstruction,
'aiida.parsers.plugins.vasp.instruction',
suffix='Instruction')
except:
raise ValueError()
def _collect_tags(node, calc,parameters=None,
dump_aiida_database=default_options['dump_aiida_database'],
exclude_external_contents=default_options['exclude_external_contents'],
gzip=default_options['gzip'],
gzip_threshold=default_options['gzip_threshold']):
"""
Retrieve metadata from attached calculation and pseudopotentials
and prepare it to be saved in TCOD CIF.
"""
import os, json
tags = { '_audit_creation_method': "AiiDA version {}".format(__version__) }
# Recording the dictionaries (if any)
if len(conforming_dictionaries):
for postfix in ['name', 'version', 'location']:
key = '_audit_conform_dict_{}'.format(postfix)
if key not in tags:
tags[key] = []
for dictionary in conforming_dictionaries:
tags['_audit_conform_dict_name'].append(dictionary['name'])
tags['_audit_conform_dict_version'].append(dictionary['version'])
tags['_audit_conform_dict_location'].append(dictionary['url'])
# Collecting metadata from input files:
calc_data = []
if calc is not None:
calc_data = _collect_calculation_data(calc)
for tag in tcod_loops['_tcod_computation'] + tcod_loops['_tcod_file']:
tags[tag] = []
export_files = []
sn = 0
fn = 0
for step in calc_data:
tags['_tcod_computation_step'].append(sn)
tags['_tcod_computation_command'].append(
'cd {}; ./{}'.format(sn,aiida_executable_name))
tags['_tcod_computation_reference_uuid'].append(step['uuid'])
if 'env' in step:
tags['_tcod_computation_environment'].append(
"\n".join(["%s=%s" % (key,step['env'][key]) for key in step['env']]))
else:
tags['_tcod_computation_environment'].append('')
if 'stdout' in step and step['stdout'] is not None:
if cif_encode_contents(step['stdout'])[1] is not None:
raise ValueError("Standard output of computation step {} "
"can not be stored in a CIF file: "
"encoding is required, but not currently "
"supported".format(sn))
tags['_tcod_computation_stdout'].append(step['stdout'])
else:
tags['_tcod_computation_stdout'].append('')
if 'stderr' in step and step['stderr'] is not None:
if cif_encode_contents(step['stderr'])[1] is not None:
raise ValueError("Standard error of computation step {} "
"can not be stored in a CIF file: "
"encoding is required, but not currently "
"supported".format(sn))
tags['_tcod_computation_stderr'].append(step['stderr'])
else:
tags['_tcod_computation_stderr'].append('')
export_files.append( {'name': "{}{}".format(sn, os.sep),
'type': 'folder'} )
for f in step['files']:
f['name'] = os.path.join(str(sn), f['name'])
export_files.extend( step['files'] )
sn = sn + 1
# Creating importable AiiDA database dump in CIF tags
if dump_aiida_database and node.is_stored:
import json
from aiida.common.exceptions import LicensingException
from aiida.common.folders import SandboxFolder
from aiida.orm.importexport import export_tree
with SandboxFolder() as folder:
try:
export_tree([node.dbnode], folder=folder, silent=True,
allowed_licenses=['CC0'])
except LicensingException as e:
raise LicensingException(e.message + \
". Only CC0 license is accepted.")
files = _collect_files(folder.abspath)
with open(folder.get_abs_path('data.json')) as f:
data = json.loads(f.read())
md5_to_url = {}
if exclude_external_contents:
for pk in data['node_attributes']:
n = data['node_attributes'][pk]
if 'md5' in n.keys() and 'source' in n.keys() and \
'uri' in n['source'].keys():
md5_to_url[n['md5']] = n['source']['uri']
for f in files:
f['name'] = os.path.join('aiida',f['name'])
if f['type'] == 'file' and f['md5'] in md5_to_url.keys():
f['uri'] = md5_to_url[f['md5']]
export_files.extend(files)
# Describing seen files in _tcod_file_* loop
encodings = list()
fn = 0
for f in export_files:
# ID and name
tags['_tcod_file_id'].append(fn)
tags['_tcod_file_name'].append(f['name'])
# Checksums
md5sum = None
sha1sum = None
if f['type'] == 'file':
md5sum = f['md5']
sha1sum = f['sha1']
else:
md5sum = '.'
sha1sum = '.'
tags['_tcod_file_md5sum'].append(md5sum)
tags['_tcod_file_sha1sum'].append(sha1sum)
# Content, encoding and URI
contents = '?'
encoding = None
if 'uri' in f.keys():
contents = '.'
tags['_tcod_file_URI'].append(f['uri'])
else:
tags['_tcod_file_URI'].append('?')
if f['type'] == 'file':
contents,encoding = \
cif_encode_contents(f['contents'],
gzip=gzip,
gzip_threshold=gzip_threshold)
else:
contents = '.'
if encoding is None:
encoding = '.'
elif encoding not in encodings:
encodings.append(encoding)
tags['_tcod_file_contents'].append(contents)
tags['_tcod_file_content_encoding'].append(encoding)
# Role
role = '?'
if 'role' in f.keys():
role = f['role']
tags['_tcod_file_role'].append(role)
fn = fn + 1
# Describing the encodings
if encodings:
for tag in tcod_loops['_tcod_content_encoding']:
tags[tag] = []
for encoding in encodings:
layers = encoding.split('+')
for i in range(0, len(layers)):
tags['_tcod_content_encoding_id'].append(encoding)
tags['_tcod_content_encoding_layer_id'].append(i+1)
tags['_tcod_content_encoding_layer_type'].append(layers[i])
# Describing Brillouin zone (if used)
if calc is not None:
from aiida.orm.data.array.kpoints import KpointsData
kpoints_list = calc.get_inputs(KpointsData)
# TODO: stop if more than one KpointsData is used?
if len(kpoints_list) == 1:
kpoints = kpoints_list[0]
density, shift = kpoints.get_kpoints_mesh()
tags['_dft_BZ_integration_grid_X'] = density[0]
tags['_dft_BZ_integration_grid_Y'] = density[1]
tags['_dft_BZ_integration_grid_Z'] = density[2]
tags['_dft_BZ_integration_grid_shift_X'] = shift[0]
tags['_dft_BZ_integration_grid_shift_Y'] = shift[1]
tags['_dft_BZ_integration_grid_shift_Z'] = shift[2]
# Collecting code-specific data
from aiida.common.pluginloader import BaseFactory, existing_plugins
from aiida.tools.dbexporters.tcod_plugins import BaseTcodtranslator
plugin_path = "aiida.tools.dbexporters.tcod_plugins"
plugins = list()
if calc is not None:
for plugin in existing_plugins(BaseTcodtranslator, plugin_path):
cls = BaseFactory(plugin, BaseTcodtranslator, plugin_path)
if calc._plugin_type_string.endswith(cls._plugin_type_string + '.'):
plugins.append(cls)
from aiida.common.exceptions import MultipleObjectsError
if len(plugins) > 1:
raise MultipleObjectsError("more than one plugin found for "
"{}".calc._plugin_type_string)
if len(plugins) == 1:
plugin = plugins[0]
translated_tags = translate_calculation_specific_values(calc,
plugin)
tags.update(translated_tags)
return tags
def PhononWorkflowsFactory(module):
from aiida.common.pluginloader import BaseFactory
return BaseFactory(module, Workflow, 'aiida.workflows.phonon')