def prepare_for_submission(self, folder):
"""
This is the routine to be called when you want to create
the input files and related stuff with a plugin.
:param folder: a aiida.common.folders.Folder subclass where
the plugin should put all its files.
"""
if 'structure' in self.inputs:
pmg_structure = self.inputs.structure.get_pymatgen_molecule()
else:
# If structure is not specified, it is read from the chk file
pmg_structure = None
# Generate the input file
input_string = GaussianCalculation._render_input_string_from_params(
self.inputs.parameters.get_dict(), pmg_structure)
with open(folder.get_abs_path(self.INPUT_FILE), "w") as out_file:
out_file.write(input_string)
settings = self.inputs.settings.get_dict(
) if "settings" in self.inputs else {}
# create code info
codeinfo = CodeInfo()
codeinfo.cmdline_params = settings.pop("cmdline", [])
codeinfo.code_uuid = self.inputs.code.uuid
codeinfo.stdin_name = self.INPUT_FILE
codeinfo.stdout_name = self.OUTPUT_FILE
codeinfo.withmpi = self.inputs.metadata.options.withmpi
# create calculation info
calcinfo = CalcInfo()
calcinfo.remote_copy_list = []
calcinfo.local_copy_list = []
calcinfo.uuid = self.uuid
calcinfo.cmdline_params = codeinfo.cmdline_params
calcinfo.stdin_name = self.INPUT_FILE
calcinfo.stdout_name = self.OUTPUT_FILE
calcinfo.codes_info = [codeinfo]
calcinfo.retrieve_list = [self.OUTPUT_FILE]
# symlink or copy to parent calculation
calcinfo.remote_symlink_list = []
calcinfo.remote_copy_list = []
if "parent_calc_folder" in self.inputs:
comp_uuid = self.inputs.parent_calc_folder.computer.uuid
remote_path = self.inputs.parent_calc_folder.get_remote_path()
copy_info = (comp_uuid, remote_path, self.PARENT_FOLDER_NAME)
if (self.inputs.code.computer.uuid == comp_uuid):
# if running on the same computer - make a symlink
# if not - copy the folder
calcinfo.remote_symlink_list.append(copy_info)
else:
calcinfo.remote_copy_list.append(copy_info)
return calcinfo
def prepare_for_submission(self, folder):
"""Create the input files from the input nodes passed to this instance of the `CalcJob`.
:param folder: an `aiida.common.folders.Folder` to temporarily write files on disk
:return: `aiida.common.datastructures.CalcInfo` instance
"""
from aiida_orca.utils import OrcaInput
# create input structure(s)
if 'structure' in self.inputs:
self._write_structure(self.inputs.structure, folder,
self._INPUT_COORDS_FILE)
settings = self.inputs.settings.get_dict(
) if 'settings' in self.inputs else {}
# create code info
codeinfo = CodeInfo()
codeinfo.cmdline_params = settings.pop('cmdline',
[]) + [self._INPUT_FILE]
codeinfo.stdout_name = self._OUTPUT_FILE
codeinfo.join_files = True
codeinfo.code_uuid = self.inputs.code.uuid
# create calc info
calcinfo = CalcInfo()
calcinfo.uuid = self.uuid
calcinfo.cmdline_params = codeinfo.cmdline_params
calcinfo.stdin_name = self._INPUT_FILE
calcinfo.stdout_name = self._OUTPUT_FILE
calcinfo.codes_info = [codeinfo]
# files or additional structures
if 'file' in self.inputs:
calcinfo.local_copy_list = []
for name, obj in self.inputs.file.items():
if name == 'gbw':
calcinfo.local_copy_list.append(
(obj.uuid, obj.filename, 'aiida_old.gbw'))
else:
calcinfo.local_copy_list.append(
(obj.uuid, obj.filename, obj.filename))
# Retrive list
calcinfo.retrieve_list = [
self._OUTPUT_FILE, self._GBW_FILE, self._HESSIAN_FILE,
self._RELAX_COORDS_FILE
]
calcinfo.retrieve_list += settings.pop('additional_retrieve_list', [])
# create ORCA input file
# inp = OrcaInput(self.inputs.parameters.get_dict(), remote_path=remote_path)
inp = OrcaInput(self.inputs.parameters.get_dict())
with io.open(folder.get_abs_path(self._INPUT_FILE), mode='w') as fobj:
fobj.write(inp.render())
return calcinfo
def prepare_for_submission(self, folder):
"""Create the input files from the input nodes passed to this instance of the `CalcJob`.
:param folder: an `aiida.common.folders.Folder` to temporarily write files on disk
:return: `aiida.common.datastructures.CalcInfo` instance
"""
self.logger.info("prepare_for_submission")
# These three lists are updated in self._create_additional_files(folder)
self._internal_retrieve_list = []
self._additional_cmd_params = []
self._calculation_cmd = []
self._create_additional_files(folder)
# ================= prepare the python input files =================
# BORN
if (not self.inputs.fc_only and 'nac_params' in self.inputs
and 'primitive' in self.inputs
and 'symmetry_tolerance' in self.inputs.settings.attributes):
born_txt = get_BORN_txt(self.inputs.nac_params,
self.inputs.primitive,
self.inputs.settings['symmetry_tolerance'])
with folder.open(self._INPUT_NAC, 'w', encoding='utf8') as handle:
handle.write(born_txt)
for params in self._additional_cmd_params:
params.append('--nac')
# ============================ calcinfo ===============================
local_copy_list = []
remote_copy_list = []
calcinfo = CalcInfo()
calcinfo.uuid = self.uuid
calcinfo.local_copy_list = local_copy_list
calcinfo.remote_copy_list = remote_copy_list
calcinfo.retrieve_list = self._internal_retrieve_list
calcinfo.codes_info = []
for i, (default_params, additional_params) in enumerate(
zip(self._calculation_cmd, self._additional_cmd_params)):
codeinfo = CodeInfo()
codeinfo.cmdline_params = default_params + additional_params
codeinfo.code_uuid = self.inputs.code.uuid
codeinfo.stdout_name = "%s%d" % (self.options.output_filename,
i + 1)
codeinfo.withmpi = False
calcinfo.codes_info.append(codeinfo)
return calcinfo
def prepare_for_submission(self, folder):
"""Create the input files from the input nodes passed to this instance of the `CalcJob`.
:param folder: an `aiida.common.folders.Folder` to temporarily write files on disk
:return: `aiida.common.datastructures.CalcInfo` instance
"""
# symlinks
calcinfo.remote_symlink_list = []
calcinfo.remote_copy_list = []
comp_uuid = self.inputs.parent_calc_folder.computer.uuid
remote_path = self.inputs.parent_calc_folder.get_remote_path()
copy_info = (comp_uuid, remote_path, self._DEFAULT_PARENT_CALC_FLDR_NAME)
if self.inputs.code.computer.uuid == comp_uuid: # if running on the same computer - make a symlink
# if not - copy the folder
calcinfo.remote_symlink_list.append(copy_info)
else:
calcinfo.remote_copy_list.append(copy_info)
# create code info
codeinfo = CodeInfo()
codeinfo.cmdline_params = ["freeze", '-o', self._DEFAULT_OUTPUT_FILE]
codeinfo.stdout_name = self._DEFAULT_OUTPUT_FILE
codeinfo.code_uuid = self.inputs.code.uuid
calcinfo.uuid = self.uuid
calcinfo.cmdline_params = codeinfo.cmdline_params
calcinfo.codes_info = [codeinfo]
calcinfo.remote_copy_list = remote_copy_list
calcinfo.remote_symlink_list = remote_symlink_list
calcinfo.retrieve_list = [
self._DEFAULT_OUTPUT_FILE,
]
# check for left over settings
if settings:
raise InputValidationError("The following keys have been found " +
"in the settings input node {}, ".format(self.pk) + "but were not understood: " +
",".join(settings.keys()))
return calcinfo
def prepare_for_submission(self, tempfolder): # pylint: disable=arguments-differ
ev1_filename = 'eigenvals1.hdf5'
ev2_filename = 'eigenvals2.hdf5'
write_bands(self.inputs.bands1, tempfolder.get_abs_path(ev1_filename))
write_bands(self.inputs.bands2, tempfolder.get_abs_path(ev2_filename))
code = self.inputs.code
calcinfo = CalcInfo()
calcinfo.uuid = self.uuid
calcinfo.remote_copy_list = []
calcinfo.retrieve_list = [self._OUTPUT_FILE_NAME]
codeinfo = CodeInfo()
codeinfo.cmdline_params = ['difference', ev1_filename, ev2_filename]
codeinfo.stdout_name = self._OUTPUT_FILE_NAME
codeinfo.code_uuid = code.uuid
calcinfo.codes_info = [codeinfo]
return calcinfo
def prepare_for_submission(self, folder):
"""
The baseclass will only setup the basic calcinfo arguments but will
not write **any** files which has to be implemented in the subclassed
prepare_for_submission() method
"""
# if no custodian code is defined directly run the VASP calculation,
# i.e. initialize the CodeInfo for the passed VASP code
if not self.inputs.custodian.get('code', False):
codeinfo = CodeInfo()
codeinfo.code_uuid = self.inputs.code.uuid
codeinfo.stdout_name = self._default_output_file
codeinfo.stderr_name = self._default_error_file
# otherwise wrap in Custodian calculation and initialize CodeInfo for
# the passed Custodian code (This is sufficient as AiiDA will scan all
# Code-inputs to generate the required prepend / append lines)
else:
codeinfo = CodeInfo()
codeinfo.code_uuid = self.inputs.custodian.code.uuid
# define custodian-exe command line arguments
codeinfo.cmdline_params = ['run', PluginDefaults.CSTDN_SPEC_FNAME]
# never add the MPI command to custodian since it will call
# VASP using MPI itself
codeinfo.withmpi = False
calcinfo = CalcInfo()
calcinfo.uuid = self.uuid
calcinfo.codes_info = [codeinfo]
# those list are set defined in the inherited classes
calcinfo.local_copy_list = []
calcinfo.remote_copy_list = []
calcinfo.remote_symlink_list = []
# retrieve lists are defined on the base class
calcinfo.retrieve_temporary_list = self.retrieve_temporary_list()
calcinfo.retrieve_list = self.retrieve_permanent_list()
# need to set run mode since presubmit() takes all code inputs into
# account and would complain if both vasp and custodian codes are set
calcinfo.codes_run_mode = CodeRunMode.SERIAL
# finally write the neccessary calculation inputs to the calculation's
# input folder
calcinfo = self.create_calculation_inputs(folder, calcinfo)
return calcinfo
def _prepare_for_submission(self, tempfolder, input_nodes_raw):
"""
This method is called prior to job submission with a set of calculation input nodes.
The inputs will be validated and sanitized, after which the necessary input files will
be written to disk in a temporary folder. A CalcInfo instance will be returned that contains
lists of files that need to be copied to the remote machine before job submission, as well
as file lists that are to be retrieved after job completion.
:param tempfolder: an aiida.common.folders.Folder to temporarily write files on disk
:param input_nodes_raw: a dictionary with the raw input nodes
:returns: CalcInfo instance
"""
input_nodes = self.validate_input_nodes(input_nodes_raw)
input_parent_folder = self.validate_input_parent_folder(input_nodes)
input_parameters = self.validate_input_parameters(input_nodes)
input_settings = input_nodes[self.get_linkname('settings')].get_dict()
input_code = input_nodes[self.get_linkname('code')]
self.write_input_files(tempfolder, input_parameters)
retrieve_list = self.get_retrieve_list(input_nodes)
local_copy_list = self.get_local_copy_list(input_nodes)
remote_copy_list = self.get_remote_copy_list(input_nodes)
# Empty command line by default
cmdline_params = input_settings.pop('CMDLINE', [])
codeinfo = CodeInfo()
codeinfo.cmdline_params = (list(cmdline_params) +
['-in', self.input_file_name])
codeinfo.stdout_name = self.output_file_name
codeinfo.code_uuid = input_code.uuid
calcinfo = CalcInfo()
calcinfo.uuid = self.uuid
calcinfo.codes_info = [codeinfo]
calcinfo.retrieve_list = retrieve_list
calcinfo.local_copy_list = local_copy_list
calcinfo.remote_copy_list = remote_copy_list
return calcinfo
def prepare_for_submission(self, folder):
"""
Create input files.
:param folder: aiida.common.folders.Folder subclass where
the plugin should put all its files.
"""
# create input files: d3
structure = self.inputs.get('structure', None)
try:
d3_content = D3(self.inputs.parameters.get_dict(), structure)
except (ValueError, NotImplementedError) as err:
raise InputValidationError(
"an input file could not be created from the parameters: {}".
format(err))
with folder.open(self._INPUT_FILE_NAME, "w") as f:
d3_content.write(f)
# create input files: fort.9
with self.inputs.wavefunction.open(mode="rb") as f:
folder.create_file_from_filelike(f,
self._WAVEFUNCTION_FILE_NAME,
mode="wb")
# Prepare CodeInfo object for aiida
codeinfo = CodeInfo()
codeinfo.code_uuid = self.inputs.code.uuid
codeinfo.stdin_name = self._INPUT_FILE_NAME
codeinfo.stdout_name = self._OUTPUT_FILE_NAME
codeinfo.withmpi = False
# Prepare CalcInfo object for aiida
calcinfo = CalcInfo()
calcinfo.uuid = self.uuid
calcinfo.codes_info = [codeinfo]
calcinfo.local_copy_list = []
calcinfo.remote_copy_list = []
calcinfo.retrieve_list = [self._PROPERTIES_FILE_NAME]
calcinfo.local_copy_list = []
return calcinfo
def prepare_for_submission(self, folder):
"""
Get ready.
"""
# We wont write anything to the `folder` since the program takes
# input as commandline parameters
code_info = CodeInfo()
code_info.cmdline_params = [str(self.inputs.x.value), str(self.inputs.y.value)]
code_info.stdout_name = self.options.output_filename
code_info.code_uuid = self.inputs.code.uuid
calc_info = CalcInfo()
calc_info.uuid = str(self.node.uuid) # ?
calc_info.codes_info = [code_info]
calc_info.retrieve_list = [self.options.output_filename]
calc_info.local_copy_list = [] # Anything that we have localy and could use
calc_info.remote_copy_list = [] # Anything that we have remotely and could use
return calc_info
def prepare_for_submission(self, tempfolder):
# Setup structure
if isinstance(self.inputs.structure, StructureData):
structure_txt, struct_transform = generate_lammps_structure(
self.inputs.structure, kinds=self.inputs.kinds)
elif isinstance(self.inputs.structure, SinglefileData):
structure_txt = self.inputs.structure.get_content()
else:
raise TypeError(
'Input structure must be StructureData or SinglefileData')
with open(self.inputs.template, 'r') as tempfile:
temp_contents = tempfile.read()
init_temp = Template(temp_contents)
input_txt = init_temp.safe_substitute(**self.inputs.variables)
if 'kinds' in self.inputs:
kind_temp = Template(input_txt)
kind_var = {
kind: kind_index + 1
for kind_index, kind in enumerate(self.inputs.kinds)
}
input_txt = kind_temp.safe_substitute(**kind_var)
# =========================== dump to file =============================
input_filename = tempfolder.get_abs_path(self._INPUT_FILE_NAME)
with open(input_filename, 'w') as infile:
infile.write(input_txt)
structure_filename = tempfolder.get_abs_path(self._INPUT_STRUCTURE)
with open(structure_filename, 'w') as infile:
infile.write(structure_txt)
# ============================ calcinfo ================================
settings = self.inputs.settings.get_dict() \
if 'settings' in self.inputs else {}
codeinfo = CodeInfo()
codeinfo.cmdline_params = self._cmdline_params
codeinfo.code_uuid = self.inputs.code.uuid
codeinfo.stdout_name = self._stdout_name
codeinfo.join_files = True
calcinfo = CalcInfo()
calcinfo.uuid = self.uuid
calcinfo.cmdline_params = codeinfo.cmdline_params
calcinfo.stdin_name = self._INPUT_FILE_NAME
calcinfo.stdout_name = self._stdout_name
calcinfo.retrieve_list = self._retrieve_list + [
self.options.output_filename
]
calcinfo.retrieve_list += settings.pop('additional_retrieve_list', [])
calcinfo.retrieve_temporary_list = self._retrieve_temporary_list
calcinfo.codes_info = [codeinfo]
# =========================== local_copy_list ==========================
if 'file' in self.inputs:
calcinfo.local_copy_list = []
for name, obj in self.inputs.file.items():
calcinfo.local_copy_list.append(
(obj.uuid, obj.filename, f'{name}.pb'))
return calcinfo
def prepare_for_submission(self, tempfolder):
# Setup template
with open(self.inputs.template, 'r') as tempfile:
temp_contents = tempfile.read()
lmp_template = Template(temp_contents)
# # check variables
# for variable in self.inputs.variables.values():
# if not isinstance(variable, list):
# raise TypeError('Values in variables must be list')
# check kinds
if 'kinds' in self.inputs:
kind_var = {
kind: kind_index + 1
for kind_index, kind in enumerate(self.inputs.kinds)
}
lmp_template = Template(lmp_template.safe_substitute(**kind_var))
for i, case in enumerate(self.inputs.cases):
structure = case.pop('structure')
if isinstance(structure, StructureData):
structure_txt, struct_transform = generate_lammps_structure(
structure, kinds=self.inputs.kinds)
elif isinstance(structure, SinglefileData):
structure_txt = structure.get_content()
else:
raise TypeError(
'Input structure must be StructureData or SinglefileData')
input_txt = lmp_template.safe_substitute(**case)
# ========================= dump to file ===========================
tempfolder.get_subfolder(i, create=True)
input_filename = tempfolder.get_abs_path(
f'{i}/{self._INPUT_FILE_NAME}')
with open(input_filename, 'w') as infile:
infile.write(input_txt)
structure_filename = tempfolder.get_abs_path(
f'{i}/{self._INPUT_STRUCTURE}')
with open(structure_filename, 'w') as infile:
infile.write(structure_txt)
case_filename = tempfolder.get_abs_path(f'{i}/case.json')
case.update({'structure pk': structure.pk})
with open(case_filename, 'w') as infile:
json.dump(case, infile, sort_keys=True, indent=2)
# ============================ calcinfo ================================
settings = self.inputs.settings.get_dict() \
if 'settings' in self.inputs else {}
codeinfo = CodeInfo()
codeinfo.cmdline_params = self._cmdline_params
codeinfo.code_uuid = self.inputs.code.uuid
codeinfo.stdout_name = self._stdout_name
codeinfo.join_files = True
calcinfo = CalcInfo()
calcinfo.uuid = self.uuid
calcinfo.prepend_text = (f'for i in $(seq 0 {i})\n'
'do\n'
'cd "${i}" || exit')
calcinfo.append_text = ('cd ..\n' 'done')
calcinfo.cmdline_params = codeinfo.cmdline_params
calcinfo.stdin_name = self._INPUT_FILE_NAME
calcinfo.stdout_name = self._stdout_name
calcinfo.retrieve_list = self._retrieve_list + [
self.options.output_filename
]
calcinfo.retrieve_list += settings.pop('additional_retrieve_list', [])
calcinfo.retrieve_temporary_list = self._retrieve_temporary_list
calcinfo.codes_info = [codeinfo]
# =========================== local_copy_list ==========================
if 'file' in self.inputs:
calcinfo.local_copy_list = []
for name, obj in self.inputs.file.items():
calcinfo.local_copy_list.append(
(obj.uuid, obj.filename, f'{name}.pb'))
return calcinfo
def prepare_for_submission(self, folder):
"""Create the input files from the input nodes passed to this instance of the `CalcJob`.
:param folder: an `aiida.common.folders.Folder` to temporarily write files on disk
:return: `aiida.common.datastructures.CalcInfo` instance
"""
from aiida_cp2k.utils import Cp2kInput
# create cp2k input file
inp = Cp2kInput(self.inputs.parameters.get_dict())
inp.add_keyword("GLOBAL/PROJECT", self._DEFAULT_PROJECT_NAME)
# create input structure(s)
if 'structure' in self.inputs:
# As far as I understand self.inputs.structure can't deal with tags
# self.inputs.structure.export(folder.get_abs_path(self._DEFAULT_COORDS_FILE_NAME), fileformat="xyz")
self._write_structure(self.inputs.structure, folder,
self._DEFAULT_COORDS_FILE_NAME)
# modify the input dictionary accordingly
for i, letter in enumerate('ABC'):
inp.add_keyword('FORCE_EVAL/SUBSYS/CELL/' + letter,
'{:<15} {:<15} {:<15}'.format(
*self.inputs.structure.cell[i]),
override=False,
conflicting_keys=[
'ABC', 'ALPHA_BETA_GAMMA', 'CELL_FILE_NAME'
])
topo = "FORCE_EVAL/SUBSYS/TOPOLOGY"
inp.add_keyword(topo + "/COORD_FILE_NAME",
self._DEFAULT_COORDS_FILE_NAME,
override=False)
inp.add_keyword(topo + "/COORD_FILE_FORMAT",
"XYZ",
override=False,
conflicting_keys=['COORDINATE'])
with io.open(folder.get_abs_path(self._DEFAULT_INPUT_FILE),
mode="w",
encoding="utf-8") as fobj:
try:
fobj.write(inp.render())
except ValueError as exc:
six.raise_from(
InputValidationError(
"invalid keys or values in input parameters found"),
exc)
settings = self.inputs.settings.get_dict(
) if 'settings' in self.inputs else {}
# create code info
codeinfo = CodeInfo()
codeinfo.cmdline_params = settings.pop(
'cmdline', []) + ["-i", self._DEFAULT_INPUT_FILE]
codeinfo.stdout_name = self._DEFAULT_OUTPUT_FILE
codeinfo.join_files = True
codeinfo.code_uuid = self.inputs.code.uuid
# create calc info
calcinfo = CalcInfo()
calcinfo.uuid = self.uuid
calcinfo.cmdline_params = codeinfo.cmdline_params
calcinfo.stdin_name = self._DEFAULT_INPUT_FILE
calcinfo.stdout_name = self._DEFAULT_OUTPUT_FILE
calcinfo.codes_info = [codeinfo]
# files or additional structures
if 'file' in self.inputs:
calcinfo.local_copy_list = []
for name, obj in self.inputs.file.items():
if isinstance(obj, SinglefileData):
calcinfo.local_copy_list.append(
(obj.uuid, obj.filename, obj.filename))
elif isinstance(obj, StructureData):
self._write_structure(obj, folder, name + '.xyz')
calcinfo.retrieve_list = [
self._DEFAULT_OUTPUT_FILE, self._DEFAULT_RESTART_FILE_NAME,
self._DEFAULT_TRAJECT_FILE_NAME
]
calcinfo.retrieve_list += settings.pop('additional_retrieve_list', [])
# symlinks
calcinfo.remote_symlink_list = []
calcinfo.remote_copy_list = []
if 'parent_calc_folder' in self.inputs:
comp_uuid = self.inputs.parent_calc_folder.computer.uuid
remote_path = self.inputs.parent_calc_folder.get_remote_path()
copy_info = (comp_uuid, remote_path,
self._DEFAULT_PARENT_CALC_FLDR_NAME)
if self.inputs.code.computer.uuid == comp_uuid: # if running on the same computer - make a symlink
# if not - copy the folder
calcinfo.remote_symlink_list.append(copy_info)
else:
calcinfo.remote_copy_list.append(copy_info)
# check for left over settings
if settings:
raise InputValidationError(
"The following keys have been found " +
"in the settings input node {}, ".format(self.pk) +
"but were not understood: " + ",".join(settings.keys()))
return calcinfo
def prepare_for_submission(
self, folder): # noqa: MC0001 - is mccabe too complex funct -
"""
Create the input files from the input nodes passed to this instance of the `CalcJob`.
:param folder: an `aiida.common.folders.Folder` to temporarily write files on disk
:return: `aiida.common.datastructures.CalcInfo` instance
"""
# ============================ Initializations =============================
# All input ports are validated, here asses their presence in case optional.
code = self.inputs.code
# self.initialize preprocess structure and basis. Decides whether use ions or pseudos
structure, basis_dict, floating_species_names, ion_or_pseudo_str = self.initialize(
)
ion_or_pseudo = self.inputs[ion_or_pseudo_str]
parameters = self.inputs.parameters
if 'kpoints' in self.inputs:
kpoints = self.inputs.kpoints
else:
kpoints = None
# As internal convention, the keys of the settings dict are uppercase
if 'settings' in self.inputs:
settings = self.inputs.settings.get_dict()
settings_dict = {str(k).upper(): v for (k, v) in settings.items()}
else:
settings_dict = {}
if 'bandskpoints' in self.inputs:
bandskpoints = self.inputs.bandskpoints
else:
bandskpoints = None
if 'parent_calc_folder' in self.inputs:
parent_calc_folder = self.inputs.parent_calc_folder
else:
parent_calc_folder = None
lua_inputs = self.inputs.lua
if 'script' in lua_inputs:
lua_script = lua_inputs.script
else:
lua_script = None
if 'parameters' in lua_inputs:
lua_parameters = lua_inputs.parameters
else:
lua_parameters = None
if 'input_files' in lua_inputs:
lua_input_files = lua_inputs.input_files
else:
lua_input_files = None
if 'retrieve_list' in lua_inputs:
lua_retrieve_list = lua_inputs.retrieve_list
else:
lua_retrieve_list = None
# List of files to copy in the folder where the calculation runs, e.g. pseudo files
local_copy_list = []
# List of files for restart
remote_copy_list = []
# ================ Preprocess of input parameters =================
input_params = FDFDict(parameters.get_dict())
input_params.update(
{'system-name': self.inputs.metadata.options.prefix})
input_params.update(
{'system-label': self.inputs.metadata.options.prefix})
input_params.update({'use-tree-timer': 'T'})
input_params.update({'xml-write': 'T'})
input_params.update({'number-of-species': len(structure.kinds)})
input_params.update({'number-of-atoms': len(structure.sites)})
input_params.update({'geometry-must-converge': 'T'})
input_params.update({'lattice-constant': '1.0 Ang'})
input_params.update({'atomic-coordinates-format': 'Ang'})
if lua_script is not None:
input_params.update({'md-type-of-run': 'Lua'})
input_params.update({'lua-script': lua_script.filename})
local_copy_list.append(
(lua_script.uuid, lua_script.filename, lua_script.filename))
if lua_input_files is not None:
# Copy the whole contents of the FolderData object
for file in lua_input_files.list_object_names():
local_copy_list.append((lua_input_files.uuid, file, file))
if ion_or_pseudo_str == "ions":
input_params.update({'user-basis': 'T'})
# NOTES:
# 1) The lattice-constant parameter must be 1.0 Ang to impose the units and consider
# that the dimenstions of the lattice vectors are already correct with no need of alat.
# This breaks the band-k-points "pi/a" option. The use of this option is banned.
# 2) The implicit coordinate convention of the StructureData class corresponds to the "Ang"
# convention in Siesta. That is why "atomic-coordinates-format" is blocked and reset.
# 3) The Siesta code doesn't raise any warining if the geometry is not converged, unless
# the keyword geometry-must-converge is set. That's why it is always added.
# ============================ Preparation of input data =================================
# -------------------------------- CELL_PARAMETERS ---------------------------------------
cell_parameters_card = "%block lattice-vectors\n"
for vector in structure.cell:
cell_parameters_card += ("{0:18.10f} {1:18.10f} {2:18.10f}"
"\n".format(*vector))
cell_parameters_card += "%endblock lattice-vectors\n"
# ----------------------------ATOMIC_SPECIES & PSEUDOS/IONS-------------------------------
atomic_species_card_list = []
# Dictionary to get the atomic number of a given element
datmn = {v['symbol']: k for k, v in elements.items()}
spind = {}
spcount = 0
for kind in structure.kinds:
spcount += 1 # species count
spind[kind.name] = spcount
atomic_number = datmn[kind.symbol]
# Siesta expects negative atomic numbers for floating species
if kind.name in floating_species_names:
atomic_number = -atomic_number
#Create the core of the chemicalspecieslabel block
atomic_species_card_list.append("{0:5} {1:5} {2:5}\n".format(
spind[kind.name], atomic_number, kind.name.rjust(6)))
psp_or_ion = ion_or_pseudo[kind.name]
# Add pseudo (ion) file to the list of files to copy (create), with the appropiate name.
# In the case of sub-species (different kind.name but same kind.symbol, e.g., 'C_surf',
# sharing the same pseudo with 'C'), we copy the file ('C.psf') twice, once as 'C.psf',
# and once as 'C_surf.psf'. This is required by Siesta.
# It is passed as list of tuples with format ('node_uuid', 'filename', 'relativedestpath').
# Since no subfolder is present in Siesta for pseudos, filename == relativedestpath.
if isinstance(psp_or_ion, IonData):
file_name = kind.name + ".ion"
with folder.open(file_name, 'w', encoding='utf8') as handle:
handle.write(psp_or_ion.get_content_ascii_format())
if isinstance(psp_or_ion, (PsfData, DeprecatedPsfData)):
local_copy_list.append(
(psp_or_ion.uuid, psp_or_ion.filename, kind.name + ".psf"))
if isinstance(psp_or_ion, (PsmlData, DeprecatedPsmlData)):
local_copy_list.append((psp_or_ion.uuid, psp_or_ion.filename,
kind.name + ".psml"))
atomic_species_card_list = (["%block chemicalspecieslabel\n"] +
list(atomic_species_card_list))
atomic_species_card = "".join(atomic_species_card_list)
atomic_species_card += "%endblock chemicalspecieslabel\n"
# Free memory
del atomic_species_card_list
# -------------------------------------- ATOMIC_POSITIONS -----------------------------------
atomic_positions_card_list = [
"%block atomiccoordinatesandatomicspecies\n"
]
countatm = 0
for site in structure.sites:
countatm += 1
atomic_positions_card_list.append(
"{0:18.10f} {1:18.10f} {2:18.10f} {3:4} {4:6} {5:6}\n".format(
site.position[0], site.position[1], site.position[2],
spind[site.kind_name], site.kind_name.rjust(6), countatm))
atomic_positions_card = "".join(atomic_positions_card_list)
del atomic_positions_card_list # Free memory
atomic_positions_card += "%endblock atomiccoordinatesandatomicspecies\n"
# --------------------------------------- K-POINTS ----------------------------------------
# It is optional, if not specified, gamma point only is performed (default of siesta)
if kpoints is not None:
mesh, offset = kpoints.get_kpoints_mesh()
kpoints_card_list = ["%block kgrid_monkhorst_pack\n"]
kpoints_card_list.append("{0:6} {1:6} {2:6} {3:18.10f}\n".format(
mesh[0], 0, 0, offset[0]))
kpoints_card_list.append("{0:6} {1:6} {2:6} {3:18.10f}\n".format(
0, mesh[1], 0, offset[1]))
kpoints_card_list.append("{0:6} {1:6} {2:6} {3:18.10f}\n".format(
0, 0, mesh[2], offset[2]))
kpoints_card = "".join(kpoints_card_list)
kpoints_card += "%endblock kgrid_monkhorst_pack\n"
del kpoints_card_list
# ------------------------------------ K-POINTS-FOR-BANDS ----------------------------------
# Two possibility are supported in Siesta: BandLines ad BandPoints.
# User can't choose directly one of the two options, BandsLine is set automatically
# if bandskpoints has labels, BandsPoints if bandskpoints has no labels.
# BandLinesScale=pi/a not supported because a=1 always. BandLinesScale ReciprocalLatticeVectors
# always set.
if bandskpoints is not None:
#the band line scale
bandskpoints_card_list = [
"BandLinesScale ReciprocalLatticeVectors\n"
]
#set the BandPoints
if bandskpoints.labels is None:
bandskpoints_card_list.append("%block BandPoints\n")
for kpo in bandskpoints.get_kpoints():
bandskpoints_card_list.append(
"{0:8.3f} {1:8.3f} {2:8.3f} \n".format(
kpo[0], kpo[1], kpo[2]))
fbkpoints_card = "".join(bandskpoints_card_list)
fbkpoints_card += "%endblock BandPoints\n"
#set the BandLines
else:
bandskpoints_card_list.append("%block BandLines\n")
savindx = []
listforbands = bandskpoints.get_kpoints()
for indx, label in bandskpoints.labels:
savindx.append(indx)
rawindex = 0
for indx, label in bandskpoints.labels:
rawindex = rawindex + 1
x, y, z = listforbands[indx]
if rawindex == 1:
bandskpoints_card_list.append(
"{0:3} {1:8.3f} {2:8.3f} {3:8.3f} {4:1} \n".format(
1, x, y, z, label))
else:
bandskpoints_card_list.append(
"{0:3} {1:8.3f} {2:8.3f} {3:8.3f} {4:1} \n".format(
indx - savindx[rawindex - 2], x, y, z, label))
fbkpoints_card = "".join(bandskpoints_card_list)
fbkpoints_card += "%endblock BandLines\n"
del bandskpoints_card_list
# ================================= Operations for restart =================================
# The presence of a 'parent_calc_folder' input node signals that we want to
# get something from there, as indicated in the self._restart_copy_from attribute.
# In Siesta's case, for now, just the density-matrix file is copied
# to the current calculation's working folder.
# ISSUE: Is this mechanism flexible enough? An alternative would be to
# pass the information about which file(s) to copy in the metadata.options dictionary
if parent_calc_folder is not None:
remote_copy_list.append(
(parent_calc_folder.computer.uuid,
os.path.join(parent_calc_folder.get_remote_path(),
self._restart_copy_from), self._restart_copy_to))
input_params.update({'dm-use-save-dm': "T"})
# ===================================== FDF file creation ====================================
# To have easy access to inputs metadata options
metadataoption = self.inputs.metadata.options
# input_filename = self.inputs.metadata.options.input_filename
input_filename = folder.get_abs_path(metadataoption.input_filename)
# Print to file
with open(input_filename, 'w') as infile:
# Parameters
for k, v in sorted(input_params.get_filtered_items()):
infile.write("%s %s\n" % (k, v))
# Basis set info is processed just like the general parameters section.
if basis_dict: #It migh also be empty dict. In such case we do not write.
infile.write("#\n# -- Basis Set Info follows\n#\n")
for k, v in basis_dict.items():
infile.write("%s %s\n" % (k, v))
# Write previously generated cards now
infile.write("#\n# -- Structural Info follows\n#\n")
infile.write(atomic_species_card)
infile.write(cell_parameters_card)
infile.write(atomic_positions_card)
if kpoints is not None:
infile.write("#\n# -- K-points Info follows\n#\n")
infile.write(kpoints_card)
if bandskpoints is not None:
infile.write("#\n# -- Bandlines/Bandpoints Info follows\n#\n")
infile.write(fbkpoints_card)
# Write max wall-clock time
# This should prevent SiestaCalculation from being terminated by scheduler, however the
# strategy is not 100% effective since SIESTA checks the simulation time versus max-walltime
# only at the end of each SCF and geometry step. The scheduler might kill the process in between.
infile.write("#\n# -- Max wall-clock time block\n#\n")
infile.write(
f"maxwalltime {metadataoption.max_wallclock_seconds}\n")
# ================================== Lua parameters file ===================================
if lua_parameters is not None:
lua_config_filename = folder.get_abs_path("config.lua")
# Generate a 'config.lua' file with Lua syntax
with open(lua_config_filename, 'w') as f_lua:
f_lua.write("--- Lua script parameters \n")
for k, v in lua_parameters.get_dict().items():
if isinstance(v, str):
f_lua.write('%s = "%s"\n' % (k, v))
else:
f_lua.write("%s = %s\n" % (k, v))
# ============================= Code and Calc info =========================================
# Code information object and Calc information object are now
# only used to set up the CMDLINE (the bash line that launches siesta)
# and to set up the list of files to retrieve.
cmdline_params = settings_dict.pop('CMDLINE', [])
codeinfo = CodeInfo()
codeinfo.cmdline_params = list(cmdline_params)
codeinfo.stdin_name = metadataoption.input_filename
codeinfo.stdout_name = metadataoption.output_filename
codeinfo.code_uuid = code.uuid
calcinfo = CalcInfo()
calcinfo.uuid = str(self.uuid)
calcinfo.local_copy_list = local_copy_list
calcinfo.remote_copy_list = remote_copy_list
calcinfo.codes_info = [codeinfo]
# Retrieve by default: the output file, the xml file, the messages file, and the json timing file.
# If bandskpoints, also the bands file is added to the retrieve list.
calcinfo.retrieve_list = []
xml_file = str(metadataoption.prefix) + ".xml"
bands_file = str(metadataoption.prefix) + ".bands"
calcinfo.retrieve_list.append(metadataoption.output_filename)
calcinfo.retrieve_list.append(xml_file)
calcinfo.retrieve_list.append(self._JSON_FILE)
calcinfo.retrieve_list.append(self._MESSAGES_FILE)
calcinfo.retrieve_list.append(self._BASIS_ENTHALPY_FILE)
calcinfo.retrieve_list.append("*.ion.xml")
if bandskpoints is not None:
calcinfo.retrieve_list.append(bands_file)
if lua_retrieve_list is not None:
calcinfo.retrieve_list += lua_retrieve_list.get_list()
# If we ever want to avoid having the config.lua file in the repository,
# since the information is already in the lua_parameters dictionary:
# if lua_parameters is not None:
# calcinfo.provenance_exclude_list = ['config.lua']
# Any other files specified in the settings dictionary
settings_retrieve_list = settings_dict.pop('ADDITIONAL_RETRIEVE_LIST',
[])
calcinfo.retrieve_list += settings_retrieve_list
return calcinfo
def prepare_for_submission(self, folder):
"""Create the input files from the input nodes passed to this instance of the `CalcJob`.
:param folder: an `aiida.common.folders.Folder` to temporarily write files on disk
:return: `aiida.common.datastructures.CalcInfo` instance
"""
from .utils import Cp2kInput
# create input structure
if "structure" in self.inputs:
self.inputs.structure.export(folder.get_abs_path(
self._DEFAULT_COORDS_FILE_NAME),
fileformat="xyz")
# create cp2k input file
inp = Cp2kInput(self.inputs.parameters.get_dict())
inp.add_keyword("GLOBAL/PROJECT", self._DEFAULT_PROJECT_NAME)
if "structure" in self.inputs:
for i, letter in enumerate("ABC"):
inp.add_keyword(
"FORCE_EVAL/SUBSYS/CELL/" + letter,
"{:<15} {:<15} {:<15}".format(
*self.inputs.structure.cell[i]),
)
topo = "FORCE_EVAL/SUBSYS/TOPOLOGY"
inp.add_keyword(topo + "/COORD_FILE_NAME",
self._DEFAULT_COORDS_FILE_NAME)
inp.add_keyword(topo + "/COORD_FILE_FORMAT", "XYZ")
with io.open(folder.get_abs_path(self._DEFAULT_INPUT_FILE),
mode="w",
encoding="utf-8") as fobj:
try:
inp.to_file(fobj)
except ValueError as exc:
six.raise_from(
InputValidationError(
"invalid keys or values in input parameters found"),
exc,
)
if "settings" in self.inputs:
settings = self.inputs.settings.get_dict()
else:
settings = {}
# create code info
codeinfo = CodeInfo()
codeinfo.cmdline_params = settings.pop("cmdline", []) + [
"-i",
self._DEFAULT_INPUT_FILE,
]
codeinfo.stdout_name = self._DEFAULT_OUTPUT_FILE
codeinfo.join_files = True
codeinfo.code_uuid = self.inputs.code.uuid
# create calc info
calcinfo = CalcInfo()
calcinfo.stdin_name = self._DEFAULT_INPUT_FILE
calcinfo.uuid = self.uuid
calcinfo.cmdline_params = codeinfo.cmdline_params
calcinfo.stdin_name = self._DEFAULT_INPUT_FILE
calcinfo.stdout_name = self._DEFAULT_OUTPUT_FILE
calcinfo.codes_info = [codeinfo]
# file lists
calcinfo.remote_symlink_list = []
if "file" in self.inputs:
calcinfo.local_copy_list = []
for fobj in self.inputs.file.values():
calcinfo.local_copy_list.append(
(fobj.uuid, fobj.filename, fobj.filename))
calcinfo.remote_copy_list = []
calcinfo.retrieve_list = [
self._DEFAULT_OUTPUT_FILE,
self._DEFAULT_RESTART_FILE_NAME,
]
calcinfo.retrieve_list += settings.pop("additional_retrieve_list", [])
# symlinks
if "parent_calc_folder" in self.inputs:
comp_uuid = self.inputs.parent_calc_folder.computer.uuid
remote_path = self.inputs.parent_calc_folder.get_remote_path()
symlink = (comp_uuid, remote_path,
self._DEFAULT_PARENT_CALC_FLDR_NAME)
calcinfo.remote_symlink_list.append(symlink)
# check for left over settings
if settings:
raise InputValidationError(
"The following keys have been found " +
"in the settings input node {}, ".format(self.pk) +
"but were not understood: " + ",".join(settings.keys()))
return calcinfo
def prepare_for_submission(self, folder):
"""Create the input files from the input nodes passed to this instance of the `CalcJob`.
:param folder: an `aiida.common.folders.Folder` to temporarily write files on disk
:return: `aiida.common.datastructures.CalcInfo` instance
"""
# create json input file
input = dict()
input['model'] = self.inputs.model.get_dict()
input['learning_rate'] = self.inputs.learning_rate.get_dict()
input['loss'] = self.inputs.loss.get_dict()
input['training'] = self.inputs.training.get_dict()
# replace all the random seed
input['model']['descriptor']['seed'] = np.random.randint(100000000)
input['model']['fitting_net']['seed'] = np.random.randint(100000000)
input['training']['seed'] = np.random.randint(100000000)
warn("All seeds in user input will be automatically replaced by numpy.")
json_str = json.dumps(input, indent=4, sort_keys=False)
with io.open(folder.get_abs_path(self._DEFAULT_INPUT_FILE), mode="w", encoding="utf-8") as fobj:
try:
fobj.write(json_str)
except ValueError as exc:
raise InputValidationError("invalid keys or values in input parameters found")
# Create the subfolder that will contain the train data
local_copy_list = []
for datadir in self.inputs.datadirs:
# change to absolute path
if not os.path.exists(datadir):
raise FileExistsError("This datadir dose not exist")
absdatadir = os.path.abspath(datadir)
# create subfolder
datadir_basename = os.path.basename(absdatadir)
datadir_in_workdir = os.path.join("./", datadir_basename)
folder.get_subfolder(datadir_in_workdir, create=True)
# this loop use to copy the training data under the datadir
for root, directories, files in os.walk(top=absdatadir, topdown=True):
relroot = os.path.relpath(root, absdatadir)
# create subtree folders
for name in directories:
folder.get_subfolder(
os.path.join(
datadir_basename,
relroot,
name),
create=True)
# give the singlefiledata to file
for name in files:
fobj = SinglefileData(
file=os.path.join(root, name)
)
# must save fobj otherwise the node is empty and can't be copied
fobj.store()
dst_path = os.path.join(
datadir_basename,
relroot,
name)
local_copy_list.append((fobj.uuid, fobj.filename, dst_path))
# settings = self.inputs.settings.get_dict() if 'settings' in self.inputs else {}
# set two code info here, once the training finished, the model will freeze then.
# create code info for training
codeinfotrain = CodeInfo()
codeinfotrain.cmdline_params = ["train", self._DEFAULT_INPUT_FILE]
#codeinfotrain.stdin_name = self._DEFAULT_INPUT_FILE
codeinfotrain.stdout_name = self._DEFAULT_TRAIN_OUTPUT_FILE
codeinfotrain.join_files = True
codeinfotrain.code_uuid = self.inputs.code.uuid
codeinfotrain.withmpi = self.inputs.metadata.options.withmpi
# create code info for freeze
codeinfofreeze = CodeInfo()
codeinfofreeze.cmdline_params = ["freeze", '-o', self._DEFAULT_FREEZE_OUTPUT_FILE]
#codeinfofreeze.stdout_name = self._DEFAULT_FREEZE_OUTPUT_FILE
codeinfofreeze.code_uuid = self.inputs.code.uuid
codeinfofreeze.withmpi = self.inputs.metadata.options.withmpi
# create calc info
calcinfo = CalcInfo()
calcinfo.uuid = self.uuid
calcinfo.local_copy_list = local_copy_list
calcinfo.codes_info = [codeinfotrain, codeinfofreeze]
calcinfo.retrieve_list = [
self._DEFAULT_TRAIN_OUTPUT_FILE,
self._DEFAULT_FREEZE_OUTPUT_FILE,
self._DEFAULT_OUTPUT_INFO_FILE,
self._DEFAULT_CHECK_META_FILE,
self._DEFAULT_CHECK_INDEX_FILE
]
return calcinfo
def prepare_for_submission(self, folder):
"""Create the input files from the input nodes passed to this instance of the `CalcJob`.
:param folder: an `aiida.common.folders.Folder` to temporarily write files on disk
:return: `aiida.common.datastructures.CalcInfo` instance
"""
self.logger.info("prepare_for_submission")
self._internal_retrieve_list = []
self._additional_cmd_params = []
self._calculation_cmd = []
settings = self.inputs.settings
structure = self.inputs.structure
code = self.inputs.code
##############################
# END OF INITIAL INPUT CHECK #
##############################
# ================= prepare the python input files =================
self._create_additional_files(folder)
cell_txt = get_poscar_txt(structure)
input_txt = get_phonopy_conf_file_txt(settings)
input_filename = folder.get_abs_path(
self.inputs.metadata.options.input_filename)
with open(input_filename, 'w') as infile:
infile.write(input_txt)
cell_filename = folder.get_abs_path(self._INPUT_CELL)
with open(cell_filename, 'w') as infile:
infile.write(cell_txt)
if ('nac_params' in self.inputs and 'primitive' in self.inputs):
born_txt = get_BORN_txt(self.inputs.nac_params,
self.inputs.primitive,
settings['symmetry_tolerance'])
nac_filename = folder.get_abs_path(self._INPUT_NAC)
with open(nac_filename, 'w') as infile:
infile.write(born_txt)
for params in self._additional_cmd_params:
params.append('--nac')
# ============================ calcinfo ===============================
local_copy_list = []
remote_copy_list = []
calcinfo = CalcInfo()
calcinfo.uuid = self.uuid
# Empty command line by default
calcinfo.local_copy_list = local_copy_list
calcinfo.remote_copy_list = remote_copy_list
# Retrieve files
calcinfo.retrieve_list = self._internal_retrieve_list
calcinfo.codes_info = []
for default_params, additional_params in zip(
self._calculation_cmd, self._additional_cmd_params):
codeinfo = CodeInfo()
codeinfo.cmdline_params = ([
self.inputs.metadata.options.input_filename,
] + default_params + additional_params)
codeinfo.code_uuid = code.uuid
codeinfo.stdout_name = self.inputs.metadata.options.output_filename
codeinfo.withmpi = False
calcinfo.codes_info.append(codeinfo)
return calcinfo
def prepare_for_submission(self, tempfolder):
"""
Create the input files from the input nodes passed to this instance of the `CalcJob`.
:param tempfolder: an `aiida.common.folders.Folder` to temporarily write files on disk
:return: `aiida.common.datastructures.CalcInfo` instance
"""
#####################################################
# BEGINNING OF INITIAL INPUT CHECK #
# All input ports that are defined via spec.input #
# are checked by default, only need to asses their #
# presence in case they are optional #
#####################################################
code = self.inputs.code
structure = self.inputs.structure
parameters = self.inputs.parameters
if 'kpoints' in self.inputs:
kpoints = self.inputs.kpoints
else:
kpoints = None
if 'basis' in self.inputs:
basis = self.inputs.basis
else:
basis = None
if 'settings' in self.inputs:
settings = self.inputs.settings.get_dict()
settings_dict = _uppercase_dict(settings, dict_name='settings')
else:
settings_dict = {}
if 'bandskpoints' in self.inputs:
bandskpoints = self.inputs.bandskpoints
else:
bandskpoints = None
if 'parent_calc_folder' in self.inputs:
parent_calc_folder = self.inputs.parent_calc_folder
else:
parent_calc_folder = None
pseudos = self.inputs.pseudos
kinds = [kind.name for kind in structure.kinds]
if set(kinds) != set(pseudos.keys()):
raise ValueError(
'Mismatch between the defined pseudos and the list of kinds of the structure.\n',
'Pseudos: {} \n'.format(', '.join(list(pseudos.keys()))),
'Kinds: {}'.format(', '.join(list(kinds))),
)
# List of the file to copy in the folder where the calculation
# runs, for instance pseudo files
local_copy_list = []
# List of files for restart
remote_copy_list = []
##############################
# END OF INITIAL INPUT CHECK #
##############################
# ============== Preprocess of input parameters ===============
# There should be a warning for duplicated (canonicalized) keys
# in the original dictionary in the script
input_params = FDFDict(parameters.get_dict())
# Look for blocked keywords and
# add the proper values to the dictionary
for blocked_key in self._aiida_blocked_keywords:
canonical_blocked = FDFDict.translate_key(blocked_key)
for key in input_params:
if key == canonical_blocked:
raise InputValidationError(
"You cannot specify explicitly the '{}' flag in the "
"input parameters".format(
input_params.get_last_key(key)))
input_params.update({'system-name': self._PREFIX})
input_params.update({'system-label': self._PREFIX})
input_params.update({'use-tree-timer': 'T'})
input_params.update({'xml-write': 'T'})
input_params.update({'number-of-species': len(structure.kinds)})
input_params.update({'number-of-atoms': len(structure.sites)})
# Regarding the lattice-constant parameter:
# -- The variable "alat" is not typically kept anywhere, and
# has already been used to define the vectors.
# We need to specify that the units of these vectors are Ang...
input_params.update({'lattice-constant': '1.0 Ang'})
# Note that this will break havoc with the band-k-points "pi/a"
# option. The use of this option should be banned.
# Note that the implicit coordinate convention of the Structure
# class corresponds to the "Ang" convention in Siesta.
# That is why the "atomic-coordinates-format" keyword is blocked
# and reset.
input_params.update({'atomic-coordinates-format': 'Ang'})
# ============== Preparation of input data ===============
# ---------------- CELL_PARAMETERS ------------------------
cell_parameters_card = "%block lattice-vectors\n"
for vector in structure.cell:
cell_parameters_card += ("{0:18.10f} {1:18.10f} {2:18.10f}"
"\n".format(*vector))
cell_parameters_card += "%endblock lattice-vectors\n"
# --------------ATOMIC_SPECIES & PSEUDOS-------------------
# I create the subfolder that will contain the pseudopotentials
tempfolder.get_subfolder(self._PSEUDO_SUBFOLDER, create=True)
# I create the subfolder with the output data
tempfolder.get_subfolder(self._OUTPUT_SUBFOLDER, create=True)
atomic_species_card_list = []
# Dictionary to get the atomic number of a given element
datmn = dict([(v['symbol'], k) for k, v in six.iteritems(elements)])
spind = {}
spcount = 0
for kind in structure.kinds:
spcount += 1 # species count
spind[kind.name] = spcount
atomic_species_card_list.append("{0:5} {1:5} {2:5}\n".format(
spind[kind.name], datmn[kind.symbol], kind.name.rjust(6)))
ps = pseudos[kind.name]
# Add this pseudo file to the list of files to copy, with
# the appropiate name. In the case of sub-species
# (different kind.name but same kind.symbol, e.g.,
# 'C_surf', sharing the same pseudo with 'C'), we will
# copy the file ('C.psf') twice, once as 'C.psf', and once
# as 'C_surf.psf'. This is required by Siesta.
# ... list of tuples with format ('node_uuid', 'filename', relativedestpath')
# We probably should be pre-pending 'self._PSEUDO_SUBFOLDER' in the
# last slot, for generality...
if isinstance(ps, PsfData):
local_copy_list.append((ps.uuid, ps.filename,
kind.name + ".psf"))
elif isinstance(ps, PsmlData):
local_copy_list.append((ps.uuid, ps.filename,
kind.name + ".psml"))
else:
pass
atomic_species_card_list = (["%block chemicalspecieslabel\n"] +
list(atomic_species_card_list))
atomic_species_card = "".join(atomic_species_card_list)
atomic_species_card += "%endblock chemicalspecieslabel\n"
# Free memory
del atomic_species_card_list
# --------------------- ATOMIC_POSITIONS -----------------------
atomic_positions_card_list = [
"%block atomiccoordinatesandatomicspecies\n"
]
countatm = 0
for site in structure.sites:
countatm += 1
atomic_positions_card_list.append(
"{0:18.10f} {1:18.10f} {2:18.10f} {3:4} {4:6} {5:6}\n".format(
site.position[0], site.position[1], site.position[2],
spind[site.kind_name], site.kind_name.rjust(6), countatm))
atomic_positions_card = "".join(atomic_positions_card_list)
del atomic_positions_card_list # Free memory
atomic_positions_card += "%endblock atomiccoordinatesandatomicspecies\n"
# -------------------- K-POINTS ----------------------------
# It is optional, if not specified, gamma point only is performed,
# this is default of siesta
if kpoints is not None:
#
# Get a mesh for sampling
# NOTE that there is not yet support for the 'kgrid-cutoff'
# option in Siesta.
#
try:
mesh, offset = kpoints.get_kpoints_mesh()
has_mesh = True
except AttributeError:
raise InputValidationError("K-point sampling for scf "
"must be given in mesh form")
kpoints_card_list = ["%block kgrid_monkhorst_pack\n"]
#
# This will fail if has_mesh is False (for the case of a list),
# since in that case 'offset' is undefined.
#
kpoints_card_list.append("{0:6} {1:6} {2:6} {3:18.10f}\n".format(
mesh[0], 0, 0, offset[0]))
kpoints_card_list.append("{0:6} {1:6} {2:6} {3:18.10f}\n".format(
0, mesh[1], 0, offset[1]))
kpoints_card_list.append("{0:6} {1:6} {2:6} {3:18.10f}\n".format(
0, 0, mesh[2], offset[2]))
kpoints_card = "".join(kpoints_card_list)
kpoints_card += "%endblock kgrid_monkhorst_pack\n"
del kpoints_card_list
# ----------------- K-POINTS-FOR-BANDS ----------------------
#Two possibility are supported in Siesta: BandLines ad BandPoints
#At the moment the user can't choose directly one of the two options
#BandsLine is set automatically if bandskpoints has labels,
#BandsPoints if bandskpoints has no labels
#BandLinesScale =pi/a is not supported at the moment because currently
#a=1 always. BandLinesScale ReciprocalLatticeVectors is always set
if bandskpoints is not None:
bandskpoints_card_list = [
"BandLinesScale ReciprocalLatticeVectors\n"
]
if bandskpoints.labels == None:
bandskpoints_card_list.append("%block BandPoints\n")
for s in bandskpoints.get_kpoints():
bandskpoints_card_list.append(
"{0:8.3f} {1:8.3f} {2:8.3f} \n".format(
s[0], s[1], s[2]))
fbkpoints_card = "".join(bandskpoints_card_list)
fbkpoints_card += "%endblock BandPoints\n"
else:
bandskpoints_card_list.append("%block BandLines\n")
savs = []
listforbands = bandskpoints.get_kpoints()
for s, m in bandskpoints.labels:
savs.append(s)
rawindex = 0
for s, m in bandskpoints.labels:
rawindex = rawindex + 1
x, y, z = listforbands[s]
if rawindex == 1:
bandskpoints_card_list.append(
"{0:3} {1:8.3f} {2:8.3f} {3:8.3f} {4:1} \n".format(
1, x, y, z, m))
else:
bandskpoints_card_list.append(
"{0:3} {1:8.3f} {2:8.3f} {3:8.3f} {4:1} \n".format(
s - savs[rawindex - 2], x, y, z, m))
fbkpoints_card = "".join(bandskpoints_card_list)
fbkpoints_card += "%endblock BandLines\n"
del bandskpoints_card_list
# ================ Operations for restart =======================
# The presence of a 'parent_calc_folder' input node signals
# that we want to get something from there, as indicated in the
# self._restart_copy_from attribute.
# In Siesta's case, for now, it is just the density-matrix file
#
# It will be copied to the current calculation's working folder.
# NOTE: This mechanism is not flexible enough.
# Maybe we should pass the information about which file(s) to
# copy in the metadata 'options' dictionary
if parent_calc_folder is not None:
remote_copy_list.append(
(parent_calc_folder.computer.uuid,
os.path.join(parent_calc_folder.get_remote_path(),
self._restart_copy_from), self._restart_copy_to))
input_params.update({'dm-use-save-dm': "T"})
# ====================== FDF file creation ========================
# To have easy access to inputs metadata options
metadataoption = self.inputs.metadata.options
# input_filename = self.inputs.metadata.options.input_filename
input_filename = tempfolder.get_abs_path(metadataoption.input_filename)
with open(input_filename, 'w') as infile:
# here print keys and values tp file
# for k, v in sorted(six.iteritems(input_params)):
for k, v in sorted(input_params.get_filtered_items()):
infile.write("%s %s\n" % (k, v))
# Basis set info is processed just like the general
# parameters section. Some discipline is needed to
# put any basis-related parameters (including blocks)
# in the basis dictionary in the input script.
#
if basis is not None:
infile.write("#\n# -- Basis Set Info follows\n#\n")
for k, v in six.iteritems(basis.get_dict()):
infile.write("%s %s\n" % (k, v))
# Write previously generated cards now
infile.write("#\n# -- Structural Info follows\n#\n")
infile.write(atomic_species_card)
infile.write(cell_parameters_card)
infile.write(atomic_positions_card)
if kpoints is not None:
infile.write("#\n# -- K-points Info follows\n#\n")
infile.write(kpoints_card)
if bandskpoints is not None:
infile.write("#\n# -- Bandlines/Bandpoints Info follows\n#\n")
infile.write(fbkpoints_card)
# Write max wall-clock time
infile.write("#\n# -- Max wall-clock time block\n#\n")
infile.write("max.walltime {}".format(
metadataoption.max_wallclock_seconds))
# ====================== Code and Calc info ========================
# Code information object and Calc information object are now
# only used to set up the CMDLINE (the bash line that launches siesta)
# and to set up the list of files to retrieve.
cmdline_params = settings_dict.pop('CMDLINE', [])
codeinfo = CodeInfo()
codeinfo.cmdline_params = list(cmdline_params)
codeinfo.stdin_name = metadataoption.input_filename
codeinfo.stdout_name = metadataoption.output_filename
codeinfo.code_uuid = code.uuid
calcinfo = CalcInfo()
calcinfo.uuid = str(self.uuid)
if cmdline_params:
calcinfo.cmdline_params = list(cmdline_params)
calcinfo.local_copy_list = local_copy_list
calcinfo.remote_copy_list = remote_copy_list
calcinfo.stdin_name = metadataoption.input_filename
calcinfo.stdout_name = metadataoption.output_filename
calcinfo.codes_info = [codeinfo]
# Retrieve by default: the output file, the xml file, the
# messages file, and the json timing file.
# If bandskpoints, also the bands file is added to the retrieve list.
calcinfo.retrieve_list = []
calcinfo.retrieve_list.append(metadataoption.output_filename)
calcinfo.retrieve_list.append(self._DEFAULT_XML_FILE)
calcinfo.retrieve_list.append(self._DEFAULT_JSON_FILE)
calcinfo.retrieve_list.append(self._DEFAULT_MESSAGES_FILE)
if bandskpoints is not None:
calcinfo.retrieve_list.append(self._DEFAULT_BANDS_FILE)
# Any other files specified in the settings dictionary
settings_retrieve_list = settings_dict.pop('ADDITIONAL_RETRIEVE_LIST',
[])
calcinfo.retrieve_list += settings_retrieve_list
return calcinfo
def prepare_for_submission(self, folder):
"""Prepare the calculation job for submission by transforming input nodes into input files.
In addition to the input files being written to the sandbox folder, a `CalcInfo` instance will be returned that
contains lists of files that need to be copied to the remote machine before job submission, as well as file
lists that are to be retrieved after job completion.
:param folder: a sandbox folder to temporarily write files on disk.
:return: :py:`~aiida.common.datastructures.CalcInfo` instance.
"""
# pylint: disable=too-many-branches,too-many-statements
import numpy as np
local_copy_list = []
remote_copy_list = []
remote_symlink_list = []
# Convert settings dictionary to have uppercase keys, or create an empty one if none was given.
if 'settings' in self.inputs:
settings_dict = _uppercase_dict(self.inputs.settings.get_dict(), dict_name='settings')
else:
settings_dict = {}
first_structure = self.inputs.first_structure
last_structure = self.inputs.last_structure
# Check that the first and last image have the same cell
if abs(np.array(first_structure.cell) - np.array(last_structure.cell)).max() > 1.e-4:
raise InputValidationError('Different cell in the fist and last image')
# Check that the first and last image have the same number of sites
if len(first_structure.sites) != len(last_structure.sites):
raise InputValidationError('Different number of sites in the fist and last image')
# Check that sites in the initial and final structure have the same kinds
if first_structure.get_site_kindnames() != last_structure.get_site_kindnames():
raise InputValidationError(
'Mismatch between the kind names and/or order between '
'the first and final image'
)
# Check that a pseudo potential was specified for each kind present in the `StructureData`
# self.inputs.pw.pseudos is a plumpy.utils.AttributesFrozendict
kindnames = [kind.name for kind in first_structure.kinds]
if set(kindnames) != set(self.inputs.pw.pseudos.keys()):
raise InputValidationError(
'Mismatch between the defined pseudos and the list of kinds of the structure.\nPseudos: {};\n'
'Kinds: {}'.format(', '.join(list(self.inputs.pw.pseudos.keys())), ', '.join(list(kindnames)))
)
##############################
# END OF INITIAL INPUT CHECK #
##############################
# Create the subfolder that will contain the pseudopotentials
folder.get_subfolder(self._PSEUDO_SUBFOLDER, create=True)
# Create the subfolder for the output data (sometimes Quantum ESPRESSO codes crash if the folder does not exist)
folder.get_subfolder(self._OUTPUT_SUBFOLDER, create=True)
# We first prepare the NEB-specific input file.
neb_input_filecontent = self._generate_input_files(self.inputs.parameters, settings_dict)
with folder.open(self.inputs.metadata.options.input_filename, 'w') as handle:
handle.write(neb_input_filecontent)
# We now generate the PW input files for each input structure
local_copy_pseudo_list = []
for i, structure in enumerate([first_structure, last_structure]):
# We need to a pass a copy of the settings_dict for each structure
this_settings_dict = copy.deepcopy(settings_dict)
pw_input_filecontent, this_local_copy_pseudo_list = PwCalculation._generate_PWCPinputdata( # pylint: disable=protected-access
self.inputs.pw.parameters, this_settings_dict, self.inputs.pw.pseudos, structure, self.inputs.pw.kpoints
)
local_copy_pseudo_list += this_local_copy_pseudo_list
with folder.open(f'pw_{i + 1}.in', 'w') as handle:
handle.write(pw_input_filecontent)
# We need to pop the settings that were used in the PW calculations
for key in list(settings_dict.keys()):
if key not in list(this_settings_dict.keys()):
settings_dict.pop(key)
# We avoid to copy twice the same pseudopotential to the same filename
local_copy_pseudo_list = set(local_copy_pseudo_list)
# We check that two different pseudopotentials are not copied
# with the same name (otherwise the first is overwritten)
if len({filename for (uuid, filename, local_path) in local_copy_pseudo_list}) < len(local_copy_pseudo_list):
raise InputValidationError('Same filename for two different pseudopotentials')
local_copy_list += local_copy_pseudo_list
# If present, add also the Van der Waals table to the pseudo dir. Note that the name of the table is not checked
# but should be the one expected by Quantum ESPRESSO.
vdw_table = self.inputs.get('pw.vdw_table', None)
if vdw_table:
local_copy_list.append(
(vdw_table.uuid, vdw_table.filename, os.path.join(self._PSEUDO_SUBFOLDER, vdw_table.filename))
)
# operations for restart
parent_calc_folder = self.inputs.get('parent_folder', None)
symlink = settings_dict.pop('PARENT_FOLDER_SYMLINK', self._default_symlink_usage) # a boolean
if symlink:
if parent_calc_folder is not None:
# I put the symlink to the old parent ./out folder
remote_symlink_list.append((
parent_calc_folder.computer.uuid,
os.path.join(parent_calc_folder.get_remote_path(), self._OUTPUT_SUBFOLDER,
'*'), # asterisk: make individual symlinks for each file
self._OUTPUT_SUBFOLDER
))
# and to the old parent prefix.path
remote_symlink_list.append((
parent_calc_folder.computer.uuid,
os.path.join(parent_calc_folder.get_remote_path(), f'{self._PREFIX}.path'), f'{self._PREFIX}.path'
))
else:
# copy remote output dir and .path file, if specified
if parent_calc_folder is not None:
remote_copy_list.append((
parent_calc_folder.computer.uuid,
os.path.join(parent_calc_folder.get_remote_path(), self._OUTPUT_SUBFOLDER,
'*'), self._OUTPUT_SUBFOLDER
))
# and copy the old parent prefix.path
remote_copy_list.append((
parent_calc_folder.computer.uuid,
os.path.join(parent_calc_folder.get_remote_path(), f'{self._PREFIX}.path'), f'{self._PREFIX}.path'
))
# here we may create an aiida.EXIT file
create_exit_file = settings_dict.pop('ONLY_INITIALIZATION', False)
if create_exit_file:
exit_filename = f'{self._PREFIX}.EXIT'
with folder.open(exit_filename, 'w') as handle:
handle.write('\n')
calcinfo = CalcInfo()
codeinfo = CodeInfo()
calcinfo.uuid = self.uuid
cmdline_params = settings_dict.pop('CMDLINE', [])
calcinfo.local_copy_list = local_copy_list
calcinfo.remote_copy_list = remote_copy_list
calcinfo.remote_symlink_list = remote_symlink_list
# In neb calculations there is no input read from standard input!!
codeinfo.cmdline_params = (['-input_images', '2'] + list(cmdline_params))
codeinfo.stdout_name = self.inputs.metadata.options.output_filename
codeinfo.code_uuid = self.inputs.code.uuid
calcinfo.codes_info = [codeinfo]
# Retrieve the output files and the xml files
calcinfo.retrieve_list = []
calcinfo.retrieve_list.append(self.inputs.metadata.options.output_filename)
calcinfo.retrieve_list.append((
os.path.join(self._OUTPUT_SUBFOLDER, self._PREFIX + '_*[0-9]', 'PW.out'), # source relative path (globbing)
'.', # destination relative path
2 # depth to preserve
))
for xml_filepath in self.xml_filepaths: # pylint: disable=not-an-iterable
calcinfo.retrieve_list.append([xml_filepath, '.', 3])
calcinfo.retrieve_list += settings_dict.pop('ADDITIONAL_RETRIEVE_LIST', [])
calcinfo.retrieve_list += self._internal_retrieve_list
# We might still have parser options in the settings dictionary: pop them.
_pop_parser_options(self, settings_dict)
if settings_dict:
unknown_keys = ', '.join(list(settings_dict.keys()))
raise InputValidationError(f'`settings` contained unexpected keys: {unknown_keys}')
return calcinfo
def prepare_for_submission(
self, folder): # noqa: MC0001 - is mccabe too complex funct -
"""
Create the input files from the input nodes passed to this instance of the `CalcJob`.
:param folder: an `aiida.common.folders.Folder` to temporarily write files on disk
:return: `aiida.common.datastructures.CalcInfo` instance
"""
code = self.inputs.code
ldos_folder = self.inputs.ldos_folder
value = self.inputs.value
spin_option = self.inputs.spin_option
mode = self.inputs.mode
# As internal convention, the keys of the settings dict are uppercase
if 'settings' in self.inputs:
settings = self.inputs.settings.get_dict()
settings_dict = {str(k).upper(): v for (k, v) in settings.items()}
else:
settings_dict = {}
# List of files for restart
remote_copy_list = []
# ======================== Creation of input file =========================
# Input file is only necessary for the old versions of plstm.
# For the new versions, all is done through command line (next section).
# To have easy access to inputs metadata options
metadataoption = self.inputs.metadata.options
# input_filename access
input_filename = folder.get_abs_path(metadataoption.input_filename)
# Getting the prefix from ldos_folder
if "prefix" in ldos_folder.creator.attributes:
prefix = str(ldos_folder.creator.get_attribute("prefix"))
else:
self.report(
"No prefix detected from the remote folder, set 'aiida' as prefix"
)
prefix = "aiida"
ldosfile = prefix + ".LDOS"
# Convert height to bohr...
if mode.value == "constant-height":
vvalue = value.value / 0.529177
else:
vvalue = value.value
with open(input_filename, 'w') as infile:
infile.write(f"{prefix}\n")
infile.write("ldos\n")
infile.write(f"{mode.value}\n")
infile.write(f"{vvalue:.5f}\n")
infile.write("unformatted\n")
# ============================== Code and Calc info ===============================
# Code information object is used to set up the the bash line that launches siesta
# (CMDLINE and input output files).
# Calc information object is to set up thee list of files to retrieve.
# The presence of a 'ldos_folder' is mandatory, to get the LDOS file as indicated in
# the self._restart_copy_from attribute. (this is not technically a restart, though)
# It will be copied to the current calculation's working folder.
remote_copy_list.append(
(ldos_folder.computer.uuid,
os.path.join(ldos_folder.get_remote_path(),
self._restart_copy_from), self._restart_copy_to))
# Empty command line by default. Why use 'pop' ?
cmdline_params = settings_dict.pop('CMDLINE', [])
# Code information object. Sets the command line
codeinfo = CodeInfo()
if mode.value == "constant-height":
cmdline_params = (list(cmdline_params) +
['-z', '{0:.5f}'.format(vvalue)])
else:
cmdline_params = (list(cmdline_params) +
['-i', '{0:.5f}'.format(vvalue)])
if spin_option.value != "q":
cmdline_params = (list(cmdline_params) +
['-s', str(spin_option.value), ldosfile])
else:
cmdline_params = (list(cmdline_params) + [ldosfile])
codeinfo.cmdline_params = list(cmdline_params)
codeinfo.stdin_name = metadataoption.input_filename
codeinfo.stdout_name = metadataoption.output_filename
codeinfo.code_uuid = code.uuid
# Calc information object. Important for files to copy, retrieve, etc
calcinfo = CalcInfo()
calcinfo.uuid = str(self.uuid)
calcinfo.local_copy_list = [
] #No local files to copy (no pseudo for instance)
calcinfo.remote_copy_list = remote_copy_list
calcinfo.codes_info = [codeinfo]
# Retrieve by default: the output file and the plot file. Some logic to understand which
# is the plot file will be in parser, here we put to retrieve every file ending in *.STM
calcinfo.retrieve_list = []
calcinfo.retrieve_list.append(metadataoption.output_filename)
calcinfo.retrieve_list.append("*.STM")
# Any other files specified in the settings dictionary
settings_retrieve_list = settings_dict.pop('ADDITIONAL_RETRIEVE_LIST',
[])
calcinfo.retrieve_list += settings_retrieve_list
return calcinfo
def prepare_for_submission(self, folder):
"""Create the input files from the input nodes passed to this instance of the `CalcJob`.
:param folder: an `aiida.common.folders.Folder` to temporarily write files on disk
:return: `aiida.common.datastructures.CalcInfo` instance
"""
# from aiida_deepmd.utils import DpInput
# create json input file
# input = DpInput(self.inputs.model.get_dict(), self.inputs.learning_rate.get_dict(), self.inputs.loss.get_dict(), self.inputs.training.get_dict())
input = dict()
input['model'] = self.inputs.model.get_dict()
input['learning_rate'] = self.inputs.learning_rate.get_dict()
input['loss'] = self.inputs.loss.get_dict()
input['training'] = self.inputs.training.get_dict()
json_str = json.dumps(input, indent=4, sort_keys=False)
with io.open(folder.get_abs_path(self._DEFAULT_INPUT_FILE), mode="w", encoding="utf-8") as fobj:
try:
fobj.write(json_str)
except ValueError as exc:
raise InputValidationError("invalid keys or values in input parameters found")
local_copy_list = []
# Create the subfolder that will contain the train data
folder.get_subfolder(self._TRAIN_DATA_SUBFOLDER, create=True)
for fn in self.inputs.file:
fobj = self.inputs.file[fn]
src_path = fobj.filename
dst_path = os.path.join(self._TRAIN_DATA_SUBFOLDER, fobj.filename)
local_copy_list.append((fobj.uuid, src_path, dst_path))
def create_array_from_files(files):
for f in files:
content = f.get_content()
# function from aiida_ce
pass
return data_array
# create train set and store the data in
data_array = create_array_from_files(self.inputs.file)
# for simplicity do not split the folder
n = 0
set_folder = folder.get_subfolder(os.path.join(self._TRAIN_DATA_SUBFOLDER, self._TRAIN_SET_PRFIX + str(n)), create=True)
with io.open(set_folder.get_abs_path(coord.npy), mode="w") as fobj:
try:
np.dump(fobj, array=data_array)
except ValueError as exc:
raise InputValidationError("invalid keys or values in input parameters found")
# settings = self.inputs.settings.get_dict() if 'settings' in self.inputs else {}
# create code info
codeinfo = CodeInfo()
codeinfo.cmdline_params = ["train", self._DEFAULT_INPUT_FILE]
codeinfo.stdout_name = self._DEFAULT_OUTPUT_FILE
codeinfo.join_files = True
codeinfo.code_uuid = self.inputs.code.uuid
# create calc info
calcinfo = CalcInfo()
calcinfo.uuid = self.uuid
calcinfo.cmdline_params = codeinfo.cmdline_params
calcinfo.stdin_name = self._DEFAULT_INPUT_FILE
calcinfo.stdout_name = self._DEFAULT_OUTPUT_FILE
calcinfo.local_copy_list = local_copy_list
calcinfo.codes_info = [codeinfo]
calcinfo.retrieve_list = [
# self._DEFAULT_OUTPUT_FILE,
# self._DEFAULT_OUTPUT_INFO_FILE,
# self._DEFAULT_CHECK_META_FILE,
# self._DEFAULT_CHECK_INDEX_FILE,
]
return calcinfo
def prepare_for_submission(self, folder):
"""
This is the routine to be called when you want to create
the input files and related stuff with a plugin.
:param folder: a aiida.common.folders.Folder subclass where
the plugin should put all its files.
"""
# create calc info
calcinfo = CalcInfo()
calcinfo.remote_copy_list = []
calcinfo.local_copy_list = []
# The main input
try:
input_string = GaussianCalculation._render_input_string_from_params(
self.inputs.parameters.get_dict(), self.inputs.structure
)
# If structure is not specified the user might want to restart from a chk
except AttributeError:
input_string = GaussianCalculation._render_input_string_from_params(
self.inputs.parameters.get_dict(), None
)
# Parse additional link1 sections
if "extra_link1_sections" in self.inputs:
for l1_name, l1_params in self.inputs.extra_link1_sections.items():
input_string += "--Link1--\n"
# The link1 secions don't support their own geometries.
input_string += GaussianCalculation._render_input_string_from_params(
l1_params.get_dict(), None
)
with open(folder.get_abs_path(self.INPUT_FILE), "w") as out_file:
out_file.write(input_string)
settings = self.inputs.settings.get_dict() if "settings" in self.inputs else {}
# create code info
codeinfo = CodeInfo()
codeinfo.cmdline_params = settings.pop("cmdline", [])
codeinfo.code_uuid = self.inputs.code.uuid
codeinfo.stdin_name = self.INPUT_FILE
codeinfo.stdout_name = self.OUTPUT_FILE
codeinfo.withmpi = self.inputs.metadata.options.withmpi
# create calculation info
calcinfo.uuid = self.uuid
calcinfo.cmdline_params = codeinfo.cmdline_params
calcinfo.stdin_name = self.INPUT_FILE
calcinfo.stdout_name = self.OUTPUT_FILE
calcinfo.codes_info = [codeinfo]
calcinfo.retrieve_list = [self.OUTPUT_FILE]
# symlink or copy to parent calculation
calcinfo.remote_symlink_list = []
calcinfo.remote_copy_list = []
if "parent_calc_folder" in self.inputs:
comp_uuid = self.inputs.parent_calc_folder.computer.uuid
remote_path = self.inputs.parent_calc_folder.get_remote_path()
copy_info = (comp_uuid, remote_path, "parent_calc")
if (
self.inputs.code.computer.uuid == comp_uuid
): # if running on the same computer - make a symlink
# if not - copy the folder
calcinfo.remote_symlink_list.append(copy_info)
else:
calcinfo.remote_copy_list.append(copy_info)
return calcinfo
def prepare_for_submission(self, folder):
"""Create the input files from the input nodes passed to this instance of the `CalcJob`.
:param folder: an `aiida.common.folders.Folder` to temporarily write files on disk
:return: `aiida.common.datastructures.CalcInfo` instance
"""
# pylint: disable=too-many-statements,too-many-branches
# Create cp2k input file.
inp = Cp2kInput(self.inputs.parameters.get_dict())
inp.add_keyword("GLOBAL/PROJECT", self._DEFAULT_PROJECT_NAME)
# Create input structure(s).
if 'structure' in self.inputs:
# As far as I understand self.inputs.structure can't deal with tags
# self.inputs.structure.export(folder.get_abs_path(self._DEFAULT_COORDS_FILE_NAME), fileformat="xyz")
self._write_structure(self.inputs.structure, folder, self._DEFAULT_COORDS_FILE_NAME)
# modify the input dictionary accordingly
for i, letter in enumerate('ABC'):
inp.add_keyword('FORCE_EVAL/SUBSYS/CELL/' + letter,
'{:<15} {:<15} {:<15}'.format(*self.inputs.structure.cell[i]),
override=False,
conflicting_keys=['ABC', 'ALPHA_BETA_GAMMA', 'CELL_FILE_NAME'])
topo = "FORCE_EVAL/SUBSYS/TOPOLOGY"
inp.add_keyword(topo + "/COORD_FILE_NAME", self._DEFAULT_COORDS_FILE_NAME, override=False)
inp.add_keyword(topo + "/COORD_FILE_FORMAT", "XYZ", override=False, conflicting_keys=['COORDINATE'])
if 'basissets' in self.inputs:
validate_basissets(inp, self.inputs.basissets,
self.inputs.structure if 'structure' in self.inputs else None)
write_basissets(inp, self.inputs.basissets, folder)
if 'pseudos' in self.inputs:
validate_pseudos(inp, self.inputs.pseudos, self.inputs.structure if 'structure' in self.inputs else None)
write_pseudos(inp, self.inputs.pseudos, folder)
# Kpoints.
if 'kpoints' in self.inputs:
try:
mesh, _ = self.inputs.kpoints.get_kpoints_mesh()
except AttributeError:
raise InputValidationError("K-point sampling for SCF must be given in mesh form.")
inp.add_keyword('FORCE_EVAL/DFT/KPOINTS', {'WAVEFUNCTIONS': ' COMPLEX', 'FULL_GRID': '.TRUE.'})
inp.add_keyword('FORCE_EVAL/DFT/KPOINTS/SCHEME MONKHORST-PACK', f'{mesh[0]} {mesh[1]} {mesh[2]}')
with io.open(folder.get_abs_path(self._DEFAULT_INPUT_FILE), mode="w", encoding="utf-8") as fobj:
try:
fobj.write(inp.render())
except ValueError as exc:
raise InputValidationError("Invalid keys or values in input parameters found") from exc
settings = self.inputs.settings.get_dict() if 'settings' in self.inputs else {}
# Create code info.
codeinfo = CodeInfo()
codeinfo.cmdline_params = settings.pop('cmdline', []) + ["-i", self._DEFAULT_INPUT_FILE]
codeinfo.stdout_name = self._DEFAULT_OUTPUT_FILE
codeinfo.join_files = True
codeinfo.code_uuid = self.inputs.code.uuid
# Create calc info.
calcinfo = CalcInfo()
calcinfo.uuid = self.uuid
calcinfo.cmdline_params = codeinfo.cmdline_params
calcinfo.stdin_name = self._DEFAULT_INPUT_FILE
calcinfo.stdout_name = self._DEFAULT_OUTPUT_FILE
calcinfo.codes_info = [codeinfo]
# Files or additional structures.
if 'file' in self.inputs:
calcinfo.local_copy_list = []
for name, obj in self.inputs.file.items():
if isinstance(obj, SinglefileData):
calcinfo.local_copy_list.append((obj.uuid, obj.filename, obj.filename))
elif isinstance(obj, StructureData):
self._write_structure(obj, folder, name + '.xyz')
calcinfo.retrieve_list = [
self._DEFAULT_OUTPUT_FILE, self._DEFAULT_RESTART_FILE_NAME, self._DEFAULT_TRAJECT_FILE_NAME
]
calcinfo.retrieve_list += settings.pop('additional_retrieve_list', [])
# Symlinks.
calcinfo.remote_symlink_list = []
calcinfo.remote_copy_list = []
if 'parent_calc_folder' in self.inputs:
comp_uuid = self.inputs.parent_calc_folder.computer.uuid
remote_path = self.inputs.parent_calc_folder.get_remote_path()
copy_info = (comp_uuid, remote_path, self._DEFAULT_PARENT_CALC_FLDR_NAME)
# If running on the same computer - make a symlink.
if self.inputs.code.computer.uuid == comp_uuid:
calcinfo.remote_symlink_list.append(copy_info)
# If not - copy the folder.
else:
calcinfo.remote_copy_list.append(copy_info)
# Check for left over settings.
if settings:
raise InputValidationError(
f"The following keys have been found in the settings input node {self.pk}, but were not understood: " +
",".join(settings.keys()))
return calcinfo
def prepare_for_submission(self, tempfolder):
"""Create the input files from the input nodes passed to this instance of the `CalcJob`.
:param tempfolder: an `aiida.common.folders.Folder` to temporarily write files on disk
:return: `aiida.common.CalcInfo` instance
"""
# assert that the potential and structure have the same kind elements
if self.inputs.potential.allowed_element_names is not None and not set(
k.symbol for k in self.inputs.structure.kinds
).issubset(self.inputs.potential.allowed_element_names):
raise ValidationError(
"the structure and potential are not compatible (different kind elements)"
)
# Setup structure
structure_txt, struct_transform = generate_lammps_structure(
self.inputs.structure, self.inputs.potential.atom_style
)
with open(
tempfolder.get_abs_path(self.options.cell_transform_filename), "w+b"
) as handle:
np.save(handle, struct_transform)
if "parameters" in self.inputs:
parameters = self.inputs.parameters
else:
parameters = Dict()
# Setup input parameters
input_txt = self.create_main_input_content(
parameter_data=parameters,
potential_data=self.inputs.potential,
kind_symbols=[kind.symbol for kind in self.inputs.structure.kinds],
structure_filename=self._INPUT_STRUCTURE,
trajectory_filename=self.options.trajectory_suffix,
system_filename=self.options.system_suffix,
restart_filename=self.options.restart_filename,
)
input_filename = tempfolder.get_abs_path(self._INPUT_FILE_NAME)
with open(input_filename, "w") as infile:
infile.write(input_txt)
self.validate_parameters(parameters, self.inputs.potential)
retrieve_list, retrieve_temporary_list = self.get_retrieve_lists()
retrieve_list.extend(
[self.options.output_filename, self.options.cell_transform_filename]
)
# prepare extra files if needed
self.prepare_extra_files(tempfolder, self.inputs.potential)
# =========================== dump to file =============================
structure_filename = tempfolder.get_abs_path(self._INPUT_STRUCTURE)
with open(structure_filename, "w") as infile:
infile.write(structure_txt)
for name, content in self.inputs.potential.get_external_files().items():
fpath = tempfolder.get_abs_path(name)
with open(fpath, "w") as infile:
infile.write(content)
# ============================ calcinfo ================================
codeinfo = CodeInfo()
codeinfo.cmdline_params = list(self._cmdline_params)
codeinfo.code_uuid = self.inputs.code.uuid
codeinfo.withmpi = self.metadata.options.withmpi
codeinfo.stdout_name = self._stdout_name
calcinfo = CalcInfo()
calcinfo.uuid = self.uuid
calcinfo.retrieve_list = retrieve_list
calcinfo.retrieve_temporary_list = retrieve_temporary_list
calcinfo.codes_info = [codeinfo]
return calcinfo
def prepare_for_submission(self, tempfolder):
"""Create the input files from the input nodes passed to this instance of the `CalcJob`.
:param tempfolder: an `aiida.common.folders.Folder` to temporarily write files on disk
:return: `aiida.common.CalcInfo` instance
"""
# assert that the potential and structure have the same kind elements
if [k.symbol for k in self.inputs.structure.kinds] != self.inputs.potential.kind_elements:
raise ValidationError("the structure and potential are not compatible (different kind elements)")
# Setup potential
potential_txt = self.inputs.potential.get_potential_file()
# Setup structure
structure_txt, struct_transform = generate_lammps_structure(
self.inputs.structure, self.inputs.potential.atom_style)
with open(tempfolder.get_abs_path(self.options.cell_transform_filename), 'w+b') as handle:
np.save(handle, struct_transform)
if "parameters" in self.inputs:
parameters = self.inputs.parameters
else:
parameters = Dict()
pdict = parameters.get_dict()
# Check lammps version date in parameters
lammps_date = convert_date_string(
pdict.get("lammps_version", '11 Aug 2017'))
# Setup input parameters
input_txt = self._generate_input_function(
parameters=parameters,
potential_obj=self.inputs.potential,
structure_filename=self._INPUT_STRUCTURE,
trajectory_filename=self.options.trajectory_name,
info_filename=self.options.info_filename,
restart_filename=self.options.restart_filename,
add_thermo_keywords=pdict.get("thermo_keywords", []),
version_date=lammps_date)
input_filename = tempfolder.get_abs_path(self._INPUT_FILE_NAME)
with open(input_filename, 'w') as infile:
infile.write(input_txt)
self.validate_parameters(parameters, self.inputs.potential)
# prepare extra files if needed
self.prepare_extra_files(tempfolder, self.inputs.potential)
# =========================== dump to file =============================
structure_filename = tempfolder.get_abs_path(self._INPUT_STRUCTURE)
with open(structure_filename, 'w') as infile:
infile.write(structure_txt)
if potential_txt is not None:
potential_filename = tempfolder.get_abs_path(
self.inputs.potential.potential_filename)
with open(potential_filename, 'w') as infile:
infile.write(potential_txt)
# ============================ calcinfo ================================
codeinfo = CodeInfo()
codeinfo.cmdline_params = self._cmdline_params
codeinfo.code_uuid = self.inputs.code.uuid
codeinfo.withmpi = False # Set lammps openmpi environment properly
codeinfo.stdout_name = self._stdout_name
calcinfo = CalcInfo()
calcinfo.uuid = self.uuid
calcinfo.retrieve_list = self._retrieve_list + [
self.options.output_filename,
self.options.cell_transform_filename]
calcinfo.retrieve_temporary_list = self._retrieve_temporary_list
calcinfo.codes_info = [codeinfo]
return calcinfo