Loops - channels between iterations

[Sriram2631]

Hello, this may be a naive question re the For and While loop nodes...

Is there a provision to pass channels/variables between two iterations of a For or While loop macro?
Or can the inputs in the dictionary being iterated be updated (dynamically) with each iteration?

[liamhuber]

For passing the output of an iteration to the input of the next iteration you'll want the while node. I'm on mobile so I don't have the syntax in front of me -- I'll link/write an example later today -- but there's an option to provide the out-to-in link as strings of the channel names in the while constructor

[liamhuber]

@Sriram2631, I realized I may have misunderstood your question -- and indeed perhaps I still do!

My brief answer that passing output of one interation into the input of the next requires a While rather than For node is still perfectly correct; For is for perfectly parallizable loops. If your loop iterations somehow depend on the original iterable input and some output of the last iteration step, While is the way to go.

I realized that an alternative interpretation to your question may be asking about while- and for-loops interacting with each other. Indeed, since the default pwf.for_node and pwf.while_node constructors give a for- or while-node instance, this is a bit tricky since these constructors require node classes to wrap.

However, we do expose the underlying class factories in pwf.api. Below is an example of how to leverage both these tools at once. It's not completely trivial, but I when I went to try it I was satisfied that we do indeed provide all the pieces necessary to bring it together. Here, I have a for loop where I "while" over the for loop with a test condition on its aggregate listified output:

import pyiron_workflow as pwf

# pwf.for_node gives a node _instance_
# To nest one inside a while loop, we'll need the _class_
# This is available in the API:
MultiplyFor = pwf.api.for_node_factory(
    pwf.std.Multiply,
    ("obj",),  # iter_on
    (),  # zip_on, none
    False,  # output_as_dataframe, Rather as list
)

demo_this_part = MultiplyFor([1, 2, 3], 3.14)
print(demo_this_part.run())
# {'obj': [1, 2, 3], 'mul': [3.14, 6.28, 9.42]}

@pwf.as_function_node("slt")
def SumLessThan(iterable: list, threshold) -> bool:
    return sum(iterable) < threshold


wf = pwf.Workflow("nested_loops")
wf.x0 = pwf.std.UserInput([1, 2, 3])
wf.dowhile = pwf.while_node(
    test_node_class=SumLessThan,
    body_node_class=MultiplyFor,
    body_to_test_connections=("mul", "iterable"),
    body_to_body_connections=("mul", "obj"),
    test_iterable=wf.x0,
    test_threshold=10,
    body_obj=wf.x0,
    body_other=1.1,
)
print(wf.run())
# {'dowhile__obj': [1.6105100000000008, 3.2210200000000015, 4.831530000000002], 'dowhile__mul': [1.771561000000001, 3.543122000000002, 5.314683000000002]}

For fun, wf.draw(size=(10,10), depth=3):

[Sriram2631]

Hi Thank you! sorry for the ambiguity, yes, I did mean an out-to-in link and I'll proceed with the while node!

However, the nested loops is an interesting exercise, say, in order to re-run a for node, or a complete workflow wrapped as a macro node, based on the output(s) in a somewhat self-consistent fashion. Intriguing! I will give both a go and update in the thread.

Thanks!