def parse_calcfunction(**kwargs): """A wrapper function that will turn calling the `Parser.parse` method into a `CalcFunctionNode`. .. warning:: This implementation of a `calcfunction` uses the `Process.current` to circumvent the limitation of not being able to return both output nodes as well as an exit code. However, since this calculation function is supposed to emulate the parsing of a `CalcJob`, which *does* have that capability, I have to use this method. This method should however not be used in process functions, in other words: Do not try this at home! :param kwargs: keyword arguments that are passed to `Parser.parse` after it has been constructed """ from aiida.engine import Process if retrieved_temporary_folder is not None: kwargs['retrieved_temporary_folder'] = retrieved_temporary_folder exit_code = parser.parse(**kwargs) outputs = parser.outputs if exit_code and exit_code.status: # In the case that an exit code was returned, still attach all the registered outputs on the current # process as well, which should represent this `CalcFunctionNode`. Otherwise the caller of the # `parse_from_node` method will get an empty dictionary as a result, despite the `Parser.parse` method # having registered outputs. process = Process.current() process.out_many(outputs) return exit_code return dict(outputs)
def setUp(self): super(TestCalcFunction, self).setUp() self.assertIsNone(Process.current()) self.default_int = Int(256) @calcfunction def test_calcfunction(data): return Int(data.value + 1) self.test_calcfunction = test_calcfunction
def setUp(self): super().setUp() self.assertIsNone(Process.current()) self.default_int = Int(256) @workfunction def test_workfunction(data): return data self.test_workfunction = test_workfunction
def tearDown(self): import os import shutil from aiida.common.folders import CALC_JOB_DRY_RUN_BASE_PATH super().tearDown() self.assertIsNone(Process.current()) # Make sure to clean the test directory that will be generated by the dry-run filepath = os.path.join(os.getcwd(), CALC_JOB_DRY_RUN_BASE_PATH) try: shutil.rmtree(filepath) except Exception: # pylint: disable=broad-except pass
def setUp(self): super().setUp() self.assertIsNone(Process.current()) self.process_class = CalculationFactory('templatereplacer') self.builder = self.process_class.get_builder() self.builder_workchain = ExampleWorkChain.get_builder() self.inputs = { 'dynamic': { 'namespace': { 'alp': orm.Int(1).store() } }, 'name': { 'spaced': orm.Int(1).store(), }, 'name_spaced': orm.Str('underscored').store(), 'boolean': orm.Bool(True).store(), 'metadata': {} }
def run_eos_wf(code, pseudo_family, element): """Run an equation of state of a bulk crystal structure for the given element.""" # This will print the pk of the work function print('Running run_eos_wf<{}>'.format(Process.current().pid)) scale_factors = (0.96, 0.98, 1.0, 1.02, 1.04) labels = ['c1', 'c2', 'c3', 'c4', 'c5'] calculations = {} # Create an initial bulk crystal structure for the given element, using the calculation function defined earlier initial_structure = create_diamond_fcc(element) # Loop over the label and scale_factor pairs for label, factor in list(zip(labels, scale_factors)): # Generated the scaled structure from the initial structure structure = rescale(initial_structure, Float(factor)) # Generate the inputs for the `PwCalculation` inputs = generate_scf_input_params(structure, code, pseudo_family) # Launch a `PwCalculation` for each scaled structure print('Running a scf for {} with scale factor {}'.format( element, factor)) calculations[label] = run(PwCalculation, **inputs) # Bundle the individual results from each `PwCalculation` in a single dictionary node. # Note: since we are 'creating' new data from existing data, we *have* to go through a `calcfunction`, otherwise # the provenance would be lost! inputs = { label: result['output_parameters'] for label, result in calculations.items() } eos = create_eos_dictionary(**inputs) # Finally, return the results of this work function result = {'initial_structure': initial_structure, 'eos': eos} return result
def setUp(self): super(TestWorkChainAbortChildren, self).setUp() self.assertIsNone(Process.current())
def tearDown(self): super(TestWorkchain, self).tearDown() self.assertIsNone(Process.current())
def setUp(self): super(TestWorkchain, self).setUp() self.assertIsNone(Process.current())
def setUp(self): super().setUp() self.assertIsNone(Process.current()) @workfunction def function_return_input(data): return data @calcfunction def function_return_true(): return get_true_node() @workfunction def function_args(data_a): return data_a @workfunction def function_args_with_default(data_a=orm.Int(DEFAULT_INT)): return data_a @calcfunction def function_with_none_default(int_a, int_b, int_c=None): if int_c is not None: return orm.Int(int_a + int_b + int_c) return orm.Int(int_a + int_b) @workfunction def function_kwargs(**kwargs): return kwargs @workfunction def function_args_and_kwargs(data_a, **kwargs): result = {'data_a': data_a} result.update(kwargs) return result @workfunction def function_args_and_default(data_a, data_b=orm.Int(DEFAULT_INT)): return {'data_a': data_a, 'data_b': data_b} @workfunction def function_defaults( data_a=orm.Int(DEFAULT_INT), metadata={ 'label': DEFAULT_LABEL, 'description': DEFAULT_DESCRIPTION } ): # pylint: disable=unused-argument,dangerous-default-value,missing-docstring return data_a @workfunction def function_default_label(): return @workfunction def function_exit_code(exit_status, exit_message): return ExitCode(exit_status.value, exit_message.value) @workfunction def function_excepts(exception): raise RuntimeError(exception.value) @workfunction def function_out_unstored(): return orm.Int(DEFAULT_INT) self.function_return_input = function_return_input self.function_return_true = function_return_true self.function_args = function_args self.function_args_with_default = function_args_with_default self.function_with_none_default = function_with_none_default self.function_kwargs = function_kwargs self.function_args_and_kwargs = function_args_and_kwargs self.function_args_and_default = function_args_and_default self.function_defaults = function_defaults self.function_default_label = function_default_label self.function_exit_code = function_exit_code self.function_excepts = function_excepts self.function_out_unstored = function_out_unstored
def tearDown(self): super(TestProcessNamespace, self).tearDown() self.assertIsNone(Process.current())
def setUp(self): super(TestCalcJob, self).setUp() self.assertIsNone(Process.current())
def setUp(self): super().setUp() self.assertIsNone(Process.current()) self.spec = Process.spec() self.spec.inputs.valid_type = Data self.spec.outputs.valid_type = Data
def setUp(self): super().setUp() self.assertIsNone(Process.current()) self.default_int = Int(256) self.test_calcfunction = add_calcfunction
def tearDown(self): super(TestLaunchers, self).tearDown() self.assertIsNone(Process.current())
def setUp(self): super(TestLaunchers, self).setUp() self.assertIsNone(Process.current()) self.a = orm.Int(1) self.b = orm.Int(2) self.result = 3
def setUp(self): super(TestLaunchersDryRun, self).setUp() self.assertIsNone(Process.current())
def tearDown(self): super(TestWorkChainAbortChildren, self).tearDown() self.assertIsNone(Process.current())
def tearDown(self): super(TestCalcJob, self).tearDown() self.assertIsNone(Process.current())
def setUp(self): super(TestProcessNamespace, self).setUp() self.assertIsNone(Process.current())
def setUp(self): super().setUp() self.assertIsNone(Process.current()) self.term_a = orm.Int(1) self.term_b = orm.Int(2) self.result = 3
def tearDown(self): super(TestProcessFunction, self).tearDown() self.assertIsNone(Process.current())
def test_spec_metadata_property(self): """`Process.spec_metadata` should return the metadata port namespace of its spec.""" self.assertIsInstance(Process.spec_metadata, PortNamespace) self.assertEqual(Process.spec_metadata, Process.spec().inputs['metadata'])
def tearDown(self): super(TestProcessBuilder, self).tearDown() self.assertIsNone(Process.current())
def setUp(self): super().setUp() self.assertIsNone(Process.current())
def setUp(self): super(TestSerializeWorkChain, self).setUp() self.assertIsNone(Process.current())
def tearDown(self): super().tearDown() self.assertIsNone(Process.current())
def tearDown(self): super(TestSerializeWorkChain, self).tearDown() self.assertIsNone(Process.current())