Better API to execute arbitrary models with arbitrary outputs

[Luthaf]

Yuxuan and I have ported a preliminary chemical shielding model to an ase-MetatensorCalculator.
This model returns atom centered non standard properties, namely the chemical shieldings.
I would feel like, that the most natural way to compute these properties woule be like this (ideally even without having to specify the domain name itself):

calc = MetatensorCalculator("model.pt")
frame.set_calculator(calc)
cs_iso = frame.get_properties(["mtt::cs_iso"])

However, currently it requires doing this, which I find not so intuitive:

output = calc.run_model(frame, outputs)
cs_iso = output['mtt::cs_iso'].block(0).values.detach().numpy()

I personally feel like the results should be stored in the results dict as numpy arrays, that way models can be used from users outside the metatensor universe.

Originally posted by @bananenpampe in metatensor/metatensor#658 (comment)

[Luthaf]

I personally feel like the results should be stored in the results dict as numpy arrays, that way models can be used from users outside the metatensor universe.

This is not possible for fully generic metatensor outputs, since they could have multiple keys/blocks, and then this function would not know what to do with them.

I agree that doing things like this would be nice, but it does not fit in the ASE calculator framework. We could however define a new API that could do what you are asking for standardized outputs, with something like this

calc = MetatensorCalculator("model.pt")
cs_iso = calc.get_metatensor_property(atoms, "scalar_chemical_shielding")

assert isinstance(cs_iso, np.ndarray)

This requires first defining what the standard outputs are and what get_metatensor_property should do for these outputs.
For example, what does this function do if there are multiple blocks in the output? What does it do if there are missing samples? How does it differentiate per atom or per structure outputs?

I'll open a separate issue to discuss this further, this PR is mainly aimed at things that should be computed together with the energy/forces.

Originally posted by @Luthaf in metatensor/metatensor#658 (comment)

[frostedoyster]

I think it's possible to have them as numpy arrays.
Something like

for key, block in tensor_map.items():
key_name = ""
for number in key:
    key_name += str(number)
atoms.arrays[output_name + key_name] = block.values.detach().cpu().numpy()