def inspect_init(self):
"""Use the initialization `PwCalculation` to determine the required resource and parallelization settings."""
calculation = self.ctx.calculation_init
if not calculation.is_finished_ok:
return self.exit_codes.ERROR_INITIALIZATION_CALCULATION_FAILED
# Get automated parallelization settings
parallelization = get_pw_parallelization_parameters(calculation, **self.ctx.automatic_parallelization)
# Note: don't do this at home, we are losing provenance here. This should be done by a calculation function
node = orm.Dict(dict=parallelization).store()
self.out('automatic_parallelization', node)
self.report('results of automatic parallelization in {}<{}>'.format(node.__class__.__name__, node.pk))
options = self.ctx.inputs.metadata['options']
base_resources = options.get('resources', {})
goal_resources = parallelization['resources']
scheduler = calculation.computer.get_scheduler()
resources = create_scheduler_resources(scheduler, base_resources, goal_resources)
cmdline = self.ctx.inputs.settings.get('cmdline', [])
cmdline = cmdline_remove_npools(cmdline)
cmdline.extend(['-nk', str(parallelization['npools'])])
# Set the new cmdline setting and resource options
self.ctx.inputs.settings['cmdline'] = cmdline
self.ctx.inputs.metadata['options'] = update_mapping(options, {'resources': resources})
# Remove the only initialization flag
self.ctx.inputs.settings.pop('ONLY_INITIALIZATION')
return
def run_init(self):
"""Run an initialization `PwCalculation` that will exit after the preamble.
In the preamble, all the relevant dimensions of the problem are computed which allows us to make an estimate of
the required resources and what parallelization flags need to be set.
"""
inputs = self.ctx.inputs
# Set the initialization flag and the initial default options
inputs.settings['ONLY_INITIALIZATION'] = True
inputs.metadata['options'] = update_mapping(inputs.metadata['options'], get_default_options())
# Prepare the final input dictionary
inputs = prepare_process_inputs(PwCalculation, inputs)
running = self.submit(PwCalculation, **inputs)
self.report('launching initialization {}<{}>'.format(running.pk, self._process_class.__name__))
return ToContext(calculation_init=running)
def inspect_init(self):
"""
Use the initialization PwCalculation to determine the required resource settings for the
requested calculation based on the settings in the automatic_parallelization input
"""
calculation = self.ctx.calculation_init
if not calculation.has_finished_ok():
self.abort_nowait(
'the initialization calculation did not finish successfully')
return
# Get automated parallelization settings
parallelization = get_pw_parallelization_parameters(
calculation, **self.ctx.automatic_parallelization)
node = ParameterData(dict=parallelization)
self.out('automatic_parallelization', node)
self.report('results of automatic parallelization in {}<{}>'.format(
node.__class__.__name__, node.pk))
options = self.ctx.inputs._options
base_resources = options.get('resources', {})
goal_resources = parallelization['resources']
scheduler = calculation.get_computer().get_scheduler()
resources = create_scheduler_resources(scheduler, base_resources,
goal_resources)
cmdline = self.ctx.inputs.settings.get('cmdline', [])
cmdline = cmdline_remove_npools(cmdline)
cmdline.extend(['-nk', str(parallelization['npools'])])
# Set the new cmdline setting and resource options
self.ctx.inputs.settings['cmdline'] = cmdline
self.ctx.inputs._options = update_mapping(options,
{'resources': resources})
# Remove the only initialization flag
self.ctx.inputs.settings.pop('ONLY_INITIALIZATION')
return
def run_init(self):
"""
Run a first dummy pw calculation that will exit straight after initialization. At that
point it will have generated some general output pertaining to the dimensions of the
calculation which we can use to distribute available computational resources
"""
inputs = self.ctx.inputs
# Set the initialization flag and the initial default options
inputs.settings['ONLY_INITIALIZATION'] = True
inputs._options = update_mapping(inputs['_options'], get_default_options())
# Prepare the final input dictionary
inputs = self._prepare_process_inputs(inputs)
process = PwCalculation.process()
running = submit(process, **inputs)
self.report('launching initialization PwCalculation<{}>'.format(running.pid))
return ToContext(calculation_init=running)