Concatenate workchain

[greschd]

Hi all!

In the aiida-optimize plugin, I've found myself writing "wrapper" workchains that modify and join together existing workchains. The details of how they are modified is defined by inputs to the wrapper workchain.

The latest iteration of these is the ConcatenateWorkChain that wraps an arbitrary number of consecutive processes, and can pass inputs between them. Here's what a simple input might look like:

submit(
    ConcatenateWorkChain,
    # The 'process_labels' define which processes are run, in which order.
    # Here, we first run `ProcessOne` and then `ProcessTwo`.
    process_labels=orm.List(
        list=[
            ('process_one', get_fullname(ProcessOne).value), # The 'get_fullname' transforms a process class into a string
            ('process_two', get_fullname(ProcessTwo).value),
        ]
    ),
    # The `process_inputs` contain any "fixed" inputs to the processes.
    process_inputs={'process_one': <inputs_dict>, 'process_two': <inputs_dict>},
    # Here we specify how outputs of one process are mapped to inputs of another
    output_input_mappings=orm.List(
        list=[(('process_one', 'process_two'), {<output_label>: <input_label>}), ]
    )
)

Conceptually, this is a different approach to programming workchains: Instead of using the outline and class methods directly to implement the behavior, it combined "pre-built" building blocks. The big advantage of this approach is that it can be dynamically modified, without needing to update the workchains the daemon knows about. The drawback is that we lose the complete programmability of regular workchains - we're limited to the building blocks that are already there.

Overall, I've found this to be great for prototyping, one-off tasks, and replacing some of my simpler workchains.

I'm trying to gauge if there's more general interest in this approach, in which case it might make sense to spin this off into a separate plugin outside of aiida-optimize.

Cheers!
Dominik