ASE optimizer's "patching"

[tomdemeyere]

Hello!

As discussed previously I wanted to introduce the concept of optimizer "patching", which would allow the user to easily modify any class based on the "Dynamics" class from ASE to make them perform additional actions.

Let's say you want to reproduce this workflow:

You can create a patch:

class ActiveLearningPatch:

     p_criteria = 0.5

     def __init__(self, model):
         self.model = model

     def step(self, *args, **kwargs):
         super().step(*args, **kwargs)
         p = calculate_uncertainty(...)
         while p < p_criteria:
                static_job_dft(...)
                self.model = build_model(...)
                p = calculate_uncertainty(self.model)
        # You get the idea.

     def run(self, *args, **kwargs):
         super().run(*args, **kwargs)

     def converged(self, *args, **kwargs):
         super().converged(*args, **kwargs)

Why not directly subclass the class you want? Because then this patch works with any ASE 'Dynamics' subclass:

• All the optimizers (except Scipy's)
• All the MDs in ASE
• Sella, and pretty much anything else based on ASE...

Why implement that in Quacc and not elsewhere? Controlling how jobs run (concurrently or not) during dynamics is very interesting.

This is a very general-purpose concept and a lot can be done with that, this is why I was thinking about implementing very specific, simple examples, like the post-processing I did in the previous PR. Each calculator would then have their patch somewhere that users can pick or build their own based on them, a little bit like presets.

There is no hurry for that, if you don't have time to discuss it, this can stay here (If you don't mind). Hopefully, someone else will comment and give their thoughts in the meantime!

[Andrew-S-Rosen]

Thanks for this nice writeup, @tomdemeyere! I think the idea is very interesting. At the same time, I feel it is perhaps a bit complicated to implement in a clean way that is: 1) Easy to use; 2) Easy to develop; 3) Easy to maintain. So, I'm a bit hesitant to consider pursuing this at the moment, as interesting/useful as the idea likely is! Happy to be proven wrong if you feel strongly otherwise. Anyway, let's keep this open. I think it is worth thinking on.