The openfe from openfreeenergy

AtomMapping correspondence lookups

depends on #20

Barebones setup

Please add as desired / tick off as sorted out

We need:

Add extra backends and reformat visualizations

As discussed with @dwhswenson the current visualization for atommappings fits our purpose but could probably be spruced up.

Potential things we should look into doing:

add a py3dmol backend so we can see atom mappings more easily
reformat the unique atoms / elements lists so they can be used by other backends
rename the d2d arguments as necessary

Add convenience methods to AtomMapping

So something that seems to be happening a lot with both drawing out mappings & using the mappings downstream is that we need to have access to:

mol2_to_mol1_map
mol1_unique_atoms (i.e. not in the map)
mol2_unique_atoms (i.e. not in the map)
atoms in the mapping that change elements

I'm opening this issue so we can consider potentially adding a couple of small methods to AtomMapping to make getting these out more easily.

Network containing Microstates

Wrap Perses AtomMapper into openfe.setup.atommapping

The task of generating a mapping between two ligands is done by an AtomMapper which generates an AtomMapping

There is an abstract base class for defining how an Atom Mapper should function here:

https://github.com/OpenFreeEnergy/openfe/blob/main/openfe/setup/ligandatommapper.py#L10

There is an Atom Mapper in perses here we could assimilate:

https://github.com/choderalab/perses/blob/main/perses/rjmc/atom_mapping.py#L543

add rdkit2oechem atommapper wrapper

Serialisation of Network container

Implement Scorer Base Implementation

s = Scorer(stuff)

m = Mapper.suggest_mapping(m1, m2)

f : float = s.score(m)

Add contributing and code of conduct information

Follow-up from #19

This will need working upstream with the OMSF folks, we'll probably need to consider things like CLA and maybe an OMSF-wide CoC policy?

Serialisation of AtomMapping container

Implement AtomMapper abstract implementation

class AtomMapper:
    @abstractmethod
    def suggest_mapping(m1: Molecule, m2: Molecule) -> Iterable[AtomMapping]:
        # magic!

    @abstractmethod
    def score(m: AtomMapping) -> float:
        # optionally implement a scorer for the maps you create (caching possible?)
        return 0.0

Solvent Molecular Representation

Convenience method for upconverting a Ligand only Network

From a Network containing ligands, add a protein and solvent to get out a network description.

Waiting on #89

Implement AlchemicalMolecule class

Holds 2x Molecule and 1x AtomMapping

User versioneer?

It would be a lot easier to just let versions be handled automatically, how do we feel about setting up versioneer?

In discussions, we've agreed that we want a documentation setup that is mostly based on Jupyter notebooks, with some room for additional RST files and the ability to get good autodoc API generation. A lot of this can be seen in the documentation for Contact Map Explorer, source here. Most of the hard work is done by nbsphinx.

The tricky part: notebooks need to be in the sphinx docs/ directory

We need to get the notebooks into the right place in the docs tree, so that nbsphinx can find them. In contact_map, the notebooks are in the repository, and this is done by copying with shutil in the conf.py. However, we don't want to include the notebook repo with the main code.

In OpenPathSampling, I wrote a script to copy files into the sphinx docs directory from any of local file, GitHub repos, or GitLab repos. It is based on a YAML input file, and so requires pyyaml to be installed in the doc building environment. It also must be run as a script before building the docs.

Neither of these are perfect for us, but I think that together they can be pieced into a good solution. Ideally, our solution would:

Copy the files over from another GitHub repo.
Run when conf.py is run, instead of in a separate script.

Other things that might be useful

Autogenerate binder links. Credit to my co-dev on contact_map for this work.
Getting version from installed code. I don't think this is default Sphinx, but since I usually need the code I'm documenting installed (for autodoc), I figure you might as well get the version from the installation.

Serialisation of Alchemical Molecule representation

Implement radial graph network planner

ligands = [Chem.MolFromSomething(f) for f in files]
central_ligand = Chem.MolFromSomething()

n: Network = openfe.setup.generate_radial_network(ligands, hub=central_ligand,
                                          mappers=[openfe.setup.mappers.SimpleMapper()])

Implement minimum spanning tree network planner

Which OS and python versions do we want to support?

I think we should follow NEP 29 when we can (I know a lot of upstream packages are slow on the 3.10 support) but it would be nice to not have to support anything older than python 3.8. I'd also like to avoid support windows if we can, and just focus on Linux and OSX support.

Molecular box hashing

AtomMapping create/delete hydrogens

Current atom mappings are probably heavy atom only, create a method which creates a new AtomMapping with hydrogens included (and reverse route, drop hydrogens)

Allow ingestion of Perses AtomMappings

Would be nice to be able to ingest an AtomMapping object from perses

m = openfe.AtomMapping.from_perses(perses_atommapping)

Serialising a Network containing Microstates

Implement Network container

Molecular box serialisation

Migrate scorers from Perses

Migrate scoring functions from Lomap

Scorers from lomap.mcs.MCS to port:

Note, Lomap uses a score where 1.0 is "good"/viable and 0.0 is bad. We use weights where 0.0 is good and larger scores are less good. Can use 1 - lomap to get same effect?

only dependencies build

Should eventually have a build on the CI which is only required dependencies (i.e. no oechem, but things still work)

Solvent hashing

Molecular box representation

Add CLI skeleton

Create a basic CLI framework that can be used with subcommands.

Migrate & annotate test data sets from Lomap

There's some nice test data sets in Lomap and it's MIT licensed too. Let's go nab them, and have a quick readme on what's inside.

Setup mypy + pre-commit hooks + pre-commit.ci

Protein Molecular Representation Container

Protein Hashing

Wrap Lomap MCS as LomapAtomMapper

Ingest Lomap network file into OpenFE network format

Lomap outputs a file, we should convert from that into a Network as best as possible.

Add method to visualise an atom mapping

Essentially we'd want our own version of what perses does here: https://github.com/choderalab/perses/blob/a8b490af0e4682082dfa442717ef45c1bd61f538/perses/rjmc/atom_mapping.py#L183-L310

See here for perses notebook: https://github.com/choderalab/perses/blob/master/examples/atom-mapping/Atom-mapping.ipynb

Use case: "I'm sitting in a notebook and I want to cycle through my atom map and see what's going on in each edge".

class AtomMapping:
    AtoB : dict[int, int]
    BtoA : dict[int, int]

Visualisation on deserialised edge throws error:

Sorry don't have time to get the full trace again, but this throws some index errors in the visualisation code paths:

# load a new network from this graphml representation
with open('network_store.graphml', 'r') as file:
    network_data = file.read()
    
new_network = Network.from_graphml(network_data)

# should trigger a display of the first edge
[edge for edge in new_network.edges][0]

openfreeenergy / openfe Goto Github PK

openfe's Introduction

openfe - A Python package for executing alchemical free energy calculations.

License

Install

Latest release

Development version

Authors

Acknowledgements

openfe's People

Contributors

Stargazers

Watchers

Forkers

openfe's Issues

The tricky part: notebooks need to be in the sphinx docs/ directory

Other things that might be useful

Recommend Projects

Recommend Topics

Recommend Org

`openfe` - A Python package for executing alchemical free energy calculations.