def prepare_for_submission(self, folder: Folder) -> CalcInfo:
"""Prepare the calculation for submission.
:param folder: a temporary folder on the local file system.
:returns: the `CalcInfo` instance
"""
echo_value = "fail" if self.node.get_option(
"fail_calcjob") else "success"
with folder.open(self.options.input_filename, "w",
encoding="utf8") as handle:
handle.write(f"sleep {self.inputs.time.value}\n")
handle.write(f'echo "{echo_value}"\n')
with folder.open(self.options.payload_filename, "wb") as handle:
json.dump(self.inputs.payload.get_dict(), handle)
codeinfo = CodeInfo()
codeinfo.code_uuid = self.inputs.code.uuid
codeinfo.stdin_name = self.options.input_filename
codeinfo.stdout_name = self.options.output_filename
calcinfo = CalcInfo()
calcinfo.codes_info = [codeinfo]
calcinfo.retrieve_list = [
self.options.output_filename,
self.options.payload_filename,
]
return calcinfo
def prepare_for_submission(self, folder: Folder) -> CalcInfo:
"""Prepare the calculation for submission.
Convert the input nodes into the corresponding input files in the format that the code will expect. In addition,
define and return a `CalcInfo` instance, which is a simple data structure that contains information for the
engine, for example, on what files to copy to the remote machine, what files to retrieve once it has completed,
specific scheduler settings and more.
:param folder: a temporary folder on the local file system.
:returns: the `CalcInfo` instance
"""
with folder.open(self.options.input_filename, 'w',
encoding='utf8') as handle:
handle.write('echo $(({x} + {y}))\n'.format(x=self.inputs.x.value,
y=self.inputs.y.value))
codeinfo = CodeInfo()
codeinfo.code_uuid = self.inputs.code.uuid
codeinfo.stdin_name = self.options.input_filename
codeinfo.stdout_name = self.options.output_filename
calcinfo = CalcInfo()
calcinfo.codes_info = [codeinfo]
calcinfo.retrieve_list = [self.options.output_filename]
return calcinfo
def prepare_for_submission(self, folder: folders.Folder):
"""Create 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._validate_inputs()
dos_filenames = OpenmxCalculation.dos_filenames
remote_symlink_list = [
(self.inputs.openmx_output_folder.computer.uuid,
os.path.join(self.inputs.openmx_output_folder.get_remote_path(),
dos_filenames['val']),
os.path.join(self._DATA_PATH, dos_filenames['val'])),
(self.inputs.openmx_output_folder.computer.uuid,
os.path.join(self.inputs.openmx_output_folder.get_remote_path(),
dos_filenames['vec']),
os.path.join(self._DATA_PATH, dos_filenames['vec'])),
]
retrieve_list = self._generate_retrieve_list()
input_file_content = self._write_input_file()
with folder.open(self._INPUT_FILE, 'w') as handle:
handle.write(input_file_content)
# Fill out the `CodeInfo`
codeinfo = datastructures.CodeInfo()
codeinfo.cmdline_params = ([
dos_filenames['val'], dos_filenames['vec']
])
codeinfo.stdin_name = self._INPUT_FILE
codeinfo.stdout_name = self._OUTPUT_FILE
codeinfo.code_uuid = self.inputs.code.uuid
codeinfo.with_mpi = True
# Fill out the `CalcInfo`
calcinfo = datastructures.CalcInfo()
calcinfo.uuid = str(self.uuid)
calcinfo.codes_info = [codeinfo]
calcinfo.remote_symlink_list = remote_symlink_list
calcinfo.retrieve_list = retrieve_list
calcinfo.retrieve_list.append(self._OUTPUT_FILE)
return calcinfo
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 dryrun_test(cls, inputs, castep_exe='castep.serial', verbose=True):
"""
Do a dryrun test in a folder with prepared builder or inputs
"""
if isinstance(inputs, ProcessBuilder):
res = cls.submit_test(inputs)
else:
res = cls.submit_test(cls, **inputs)
folder = Folder(res[1])
dry_run_node = res[0]
seedname = dry_run_node.get_option('seedname')
def _print(inp):
if verbose:
print(inp)
# Do a dryrun
try:
output = check_output([castep_exe, "-v"], universal_newlines=True)
except OSError:
_print("CASTEP executable '{}' is not found".format(castep_exe))
return None
# Now start dryrun
_print("Running with {}".format(
check_output(["which", castep_exe], universal_newlines=True)))
_print(output)
_print("Starting dryrun...")
call([castep_exe, "--dryrun", seedname], cwd=folder.abspath)
# Check if any *err files
contents = folder.get_content_list()
for fname in contents:
if fnmatch(fname, "*.err"):
with folder.open(fname) as fhandle:
_print("Error found in {}:\fname".format(fname))
_print(fhandle.read())
raise InputValidationError("Error found during dryrun")
# Gather information from the dryrun file
dryrun_results = {}
out_file = seedname + '.castep'
with folder.open(out_file) as fhandle:
for line in fhandle:
mth = re.match(r"\s*k-Points For SCF Sampling:\s+(\d+)\s*",
line)
if mth:
dryrun_results["num_kpoints"] = int(mth.group(1))
_print("Number of k-points: {}".format(mth.group(1)))
mth = None
continue
mth = re.match(
r"\| Approx\. total storage required"
r" per process\s+([0-9.]+)\sMB\s+([0-9.]+)", line)
if mth:
dryrun_results["memory_MB"] = (float(mth.group(1)))
dryrun_results["disk_MB"] = (float(mth.group(2)))
_print("RAM: {} MB, DISK: {} MB".format(
mth.group(1), mth.group(2)))
mth = None
continue
return folder, dryrun_results
def prepare_for_submission(self, folder: folders.Folder):
"""Create 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
"""
# To be filled out below
local_copy_list = []
remote_copy_list = []
remote_symlink_list = []
# Create the subfolders for pseudopotentials and orbitals
folder.get_subfolder(self._PSEUDO_SUBFOLDER, create=True)
folder.get_subfolder(self._ORBITAL_SUBFOLDER, create=True)
# Get an uppercase-key-only version of the settings dictionary (also check for case-insensitive duplicates)
if 'settings' in self.inputs:
settings = uppercase_dict_keys(self.inputs.settings.get_dict(),
dict_name='settings')
else:
settings = {}
# Get an uppercase-key-only verion of the parameters dictionary (also check for case-insensitive duplicates)
parameters = uppercase_dict_keys(self.inputs.parameters.get_dict(),
dict_name='parameters')
# No reserved parameter keywords should be provided
self._check_reserved_keywords(parameters)
# Load parameter schema
with open(self._INPUT_SCHEMA, 'r') as stream:
schema = json.load(stream)
# Automatically generate input parameters for derived fields, e.g. structure -> Atoms.Unitvectors, etc.
parameters = self._generate_input_parameters(
self.inputs.structure, self.inputs.kpoints, parameters,
self.inputs.pseudos, self.inputs.orbitals,
self.inputs.orbital_configurations)
# Get a lowercase-value-only version of the parameters dictionary
parameters = lowercase_dict_values(parameters)
# Validate input parameters
self._validate_inputs(self.inputs.structure, self.inputs.kpoints,
parameters, self.inputs.pseudos,
self.inputs.orbitals,
self.inputs.orbital_configurations, schema)
# Get input file contents and lists of the pseudopotential and orbital files which need to be copied
input_file_content = write_input_file(parameters, schema)
local_copy_pseudo_list, local_copy_orbital_list = self._generate_local_copy_lists(
self.inputs.pseudos, self.inputs.orbitals)
local_copy_list += local_copy_pseudo_list
local_copy_list += local_copy_orbital_list
# Add output files to retrieve which have been specified to write in the input parameters
retrieve_list = []
if parameters.get('BAND_NKPATH', 0) > 0 and parameters.get(
'SCF_EIGENVALUESOLVER', 'band') == 'band':
retrieve_list.append(self._DATAFILE_BAND_FILE)
if parameters.get('MD_TYPE', 'nomd') != 'nomd':
retrieve_list.append(self._DATAFILE_MD_FILE)
retrieve_list.append(self._DATAFILE_MD2_FILE)
# Write input file
with folder.open(self._INPUT_FILE, 'w') as handle:
handle.write(input_file_content)
# Fill out the `CodeInfo`
codeinfo = datastructures.CodeInfo()
codeinfo.code_uuid = self.inputs.code.uuid
codeinfo.withmpi = True
codeinfo.cmdline_params = ([self._INPUT_FILE] +
list(settings.pop('CMDLINE', [])))
codeinfo.stdout_name = self._OUTPUT_FILE
# Fill out the `CalcInfo`
calcinfo = datastructures.CalcInfo()
calcinfo.uuid = str(self.uuid)
calcinfo.codes_info = [codeinfo]
calcinfo.local_copy_list = local_copy_list
calcinfo.remote_copy_list = remote_copy_list
calcinfo.remote_symlink_list = remote_symlink_list
calcinfo.retrieve_list = retrieve_list
calcinfo.retrieve_list.append(self._OUTPUT_FILE)
calcinfo.retrieve_list += settings.pop('ADDITIONAL_RETRIEVE_LIST', [])
# TODO: pop parser settings and report remaining unknown settings
return calcinfo