Refactor macros

[liamhuber]

Old: define a generic macro shared by all atomistics workflows leveraging task generators, then define a set of macros each of which instantiates the task generator node and the generic macro node, then connects them and manually re-maps all the task generator input to be available at the macro level.

New: Create a meta-workflow that takes the task generator node as input and returns a macro class in which all the task generator IO has been dynamically re-mapped to be available at the macro level; instantiate this meta-macro once per task generator to get a set of macros.

There is absolutely nothing wrong with the "old" version, it's a perfectly legitimate and legal way to construct a set of macros! Further, the biggest advantage of the "new" way -- that the task generator input is dynamically remapped -- could also be used right in the "old" way. Using a "meta-macro" is purely stylistic and my personal preference.

@jan-janssen, it's your node package so I think it's fair if you use whatever one you prefer. However, if you chose to stick with the implementation on the base branch, I would still suggest to leverage the same dynamic remapping just to shorten the node definitions.

from pyiron_workflow import Workflow

Workflow.register("macros", "pyiron_workflow.atomistics_library.macronodes")
Workflow.register("calculators", "pyiron_workflow.atomistics_library.calculatornodes")
Workflow.register("tasks", "pyiron_workflow.atomistics_library.tasknodes")

wf = Workflow("ev")
wf.bulk = wf.create.tasks.GetBulk("Al")
wf.calc = wf.create.calculators.GetEmt()
# wf.old_ev_curve = wf.create.macros.GetEnergyVolumeCurve(
#     structure=wf.bulk,
#     calculator=wf.calc,
# )
wf.new_ev_curve = wf.create.macros.EnergyVolumeCurve(
    structure=wf.bulk,
    calculator=wf.calc,
)
out = wf()

# out.old_ev_curve__internal__fit__result_dict["poly_fit"] - out.new_ev_curve__result_dict["poly_fit"]

The commented out stuff works on the first commit of this PR, where both old and new exist at once. The output is just an array of zeros, as expected and desired.

I didn't do the same sort of thorough test for the other two, but I did make sure that they instantiated OK and had nice clean IO:

p = Workflow.create.macros.Phonons()
p.inputs.labels, p.outputs.labels

(['structure',
  'interaction_range',
  'factor',
  'displacement',
  'dos_mesh',
  'primitive_matrix',
  'number_of_snapshots',
  'calculator'],
 ['result_dict'])

and

l = Workflow.create.macros.ElasticMatrix()
l.inputs.labels, l.outputs.labels

(['structure',
  'num_points',
  'fit_type',
  'fit_order',
  'vol_range',
  'axes',
  'strains',
  'calculator'],
 ['internal__fit__result_dict'])

[github-actions]

👈 Launch a binder notebook on branch pyiron/pyiron_workflow/refactor_macros

[jan-janssen]

Looks good to me