Think of a logic to take advantage of embedders and kernels

[Ramlaoui]

Currently this codebase is structured in the following way:

• Hashers are objects that assign a string to materials

  • Materials can be compared to each others by checking whether the strings are equal.
  • Currently PDD is implemented as a hasher, but can actually be seen as something else because it returns an array for a given structure. While the logic of hashers allow to have such implementations, we might want to move this somewhere else.

• Similarity matchers that return True or False if they match two structures without returning anything for a given structure.

  • Pymatgen's StructureMatcher is a good example of a similarity matcher because crystals are not embedded individually.
  • Currently EquiformerV2is implemented as a similarity matcher but it acts somewhat similarly to PDD because vectors are returned for every structure which can then be compared. The current implementation is not efficient and does not scale well, while the model should by design be scalable.

There are different ways to tackle this:

1. We can extend the scope of hashers to not only be strings and write the useful functions that can operate on kernels. This would allow to move EquiformerV2 as a hasher.
2. We can think of a third type of objects that are neither hashers nor similarity matchers and that can return anything for a given structure which can then be compared between themselves. This object can be for example called an embedded.

Having a good way to categorize these algorithms could be a good way to expand on the codebase and add more useful functions in the long run.