membrane and arbitrary solvent support

[atravitz]

As a continuation of this issue, we know we will want to support representation of membranes, and ideally support solvents of any complexity.

Please focus on anticipated use-cases and requirements. Also include concerns you may have from a usability or performance standpoint, but don't worry about implementation yet.

We will follow-up with a discussion on how best to actually implement these ideas after the requirements are decided.

[IAlibay]

I'll try to spell out a couple of use cases (may update this post).

A simulation of a protein-membrane system

The TLDR needs

• Ingest a PDB with a presolvated system including waters, ions, lipids, and a protein (all of which are defined by a standard AMBER FF)
• Ingest one or more SMC defining the ligands and cofactors (this is flawed because of what @jthorton brought up - we parameterize smcs differently)
• Have a way to define the presence of solvent in the chemicalsystem.
• Have a way to convert the fully solvated system (protein + ions + waters + lipids) into an openmm topology.
• Profit

What the user is expected to bring ahead of time

• A pre-equilibrated system, with the protein, lipids, waters, and ions.
• A box with a unit cell that is not just cubic but possibly any other kind of cell that can be defined by triclinic box vectors.
• Some information about which atoms are bonded together for non-standard residues, but no explicit bond orders.
• Information about the coordinates and system topology provided by a PDB, and possibly the unit cell in the CRYST1 remarks or separately provided when loading my system.
• The different residues in the input PDB matching residues defined in the templates provided in a relevant force field selected from openmmforcefields.
• Molecules may be broken across periodic boundaries.

The user experience

• The workflow ideally should be very similar (if not the same) as creating a ProteinComponent without a fully solvated box (i.e. the crytal water case, where you load a PDB, you get a protein and some crystal waters and maybe some ions).
• The user ideally shouldn't have to manually split out the solvent from their PDB (i.e. you should ideally be ingesting a single PDB file).
• The user ideally shouldn't have to provide separate rdkit molecules (or equivalent) for every molecule in a solvated system. However, they may be expected to pass through an mmCIF or similar to define the bond orders of non-standard molecules in an input PDB/PDBx file.
• The user could be expected to manually provide box vectors, assuming we have tooling in place to convert between triclinic box to triclinic vectors, etc...
• The user could be expected to user different types of solvent components when defining either a "bring your own box" or "we will solvate it for you" situation.

The Protocol developer needs

• The ChemicalSystem should directly be able to tell us if it has solvent, ideally defining a SolventComponent directly. The way this is done should be the same in all cases so we can use a single method for validating a system.
• The ChemicalSystem should ideally be diff-able between states A and B to find alchemical components without relying on the mapping.
• The "bring your own box" and "we'll solvate it for you" cases should be easily identiable (an isinstance check? expecting a given attribute?), allowing for a simple if/else on system preparation.
• The "bring your own box" solvent should be easily turned into an openmm topology.
• The "bring your own box" solvent should really be contained within a single Component (i.e. the Protocols shouldn't need to take on the cost of tracking and combining several solvents together).
• The "bring your own box" solvent and "we'll solvate it for you" should have things like box vectors defined in a similar place (currently the latter is defined in settings rather than components/chemicalsystem).
• Residue names from the solvent / lipids should be retained in a way that OpenMM FF templates can be used.

[IAlibay]

A Packmol-generated arbitrary solvent system (via Interchange?)

This describes the arbitrary solvent case where we don't necessarily expect lipids, but rather a system packed using Packmol in the way we do in Pontibus.

What the user would be expected to bring

• An interchange object or an OpenFF Topology
• Box vectors

The user experience

• Bring the Interchange / Topology object
• Ideally don't have to manually split up the "solvent" from other components.
• Would be expected to somehow define what force field is applied to what portions of the system.

The Protocol needs

• Know that the system is solvated
• Be able to diff between the two end states to easily find the alchemical molecules.
• Know what parts of the system should be parameterised with what FF (if we're mixing both OpenFF and OpenMM/AMBER FFs)
• Have FF assignment tooling that allows for arbitrary parts of the system to be parameterize using OpenFF or OpenMMForceFields/AMBER (this is the SystemGenerator replacement we've discussed in the past)
• Easily know where the box vectors are in a way that is consistent with systems ingested in other ways (e.g. from a PDB)
• Have residue names available.

[jthorton]

Based on my limited experience with membranes

Protein membrane simulations

User experience

Assuming that OpenFE will not be getting into the membrane setup game and that a user should come with their fully prepared system and run a normal BFE calculation on a SMC and that no transformations are done to the lipid layer.

• Create a PtoteinComponent (maybe renamed to show it represents more than just the protein) with water, lipids, ions, protein and box vectors prepared with some standard tool like Charmm-gui/openmm with minimal input. Here we assume that any lipids defined by standard amber FF like lipid17 should be automatically recognised so the mmCIF files and bond order information is not required to create a smooth experience.
• A property should be added to the component that can be used to determine if a membrane or water is present, this could be based on the identification of repeated residue names. If we don't want to do this automatically, it could be a user set flag during object creation. This could then be used later by protocols to ensure the correct simulation settings are used like the MonteCarloMembraneBarostat in openmm rather than having the user change the setting in the protocol.
• Only cofators and ligands should have been extracted from the file and supplied as a SMC to signal that the small molecule ff should be used for the parameterization (maybe a flag on SMC to signal if it should be the small molecule ff or not).
• By not providing a solvation component to the chemical system we signal that the system is already solvated and that the protocol should use the box vectors in the input to run the simulation.
• Box vectors should be extracted from the input.
• Network planning via the API and CLI should work the same with a membrane protein system, maybe with a new flag for the CLI to signal the protein component now contains a membrane if we add the property idea from above.
• The saved transformation should be executed and analysed in the same way as other protocols.
• Transformations using membranes should have some sensible default settings that have been validated if I don't want to choose my own.
• Both RBFE and ABFE should be supported.

Protocol devs

• We should assume that the user has signalled this is a membrane system and automatically use the correct barostat and report this in the logs.
• The box vector should be stored on the input component.
• We should recognise that there is no solvent component and not solvate the system this should be reported in the logs, we should fail if we can not find a box vector in the input system.
• The rest of the protocol should work as normal, the components are converted to an openmm topology and the hybrid factory is made.

Questions?

• Do we need some new structure analysis methods for the lipids?
• Do we need specific settings to only save part of the lipid layer near the binding site/ SMC will the files be too big?

A Packmol-generated arbitrary solvent system (via Interchange?)

Here I am mainly thinking about solvation free energies where a SMC is in a box of solvent which should also be represented by the small molecule ff but we don't want the user to have to extract everything into an SMC and then combine everything back together.

User

• Supply a pdb file with the solvent and SMC with the solute, also supply the bonding information for the solvent so that the small molecule ff can be applied to it.
• Box vectors from the input should be automatically used.
• Providing no solvent component should signify that the system is solvated.

Protocol Devs

• Maybe create a template solvent component which would have the bonding information of a single copy of the solute molecule this will be passed to the small molecule template generator and used to get the parameters for the solute. Having this would signify that no solvent should be added to the system and that the box vectors supplied should be used. This would only be expected for non-water solvents.

[hannahbaumann]

Simulation of a protein-membrane system

User experience

• Input:
  • solvated and well equilibrated protein-membrane system, including the protein, lipids, ions. For the lipids, a wide range of lipids should be supported
  • ligands and cofactors in a separate file
• All current protocols should support this (MD, ABFE, RBFE protocols)
• The user does not supply a SolventComponent. This indicates that a presolvated system is used
• The setup should be very similar compared to the setup where systems are solvated

Protocol devs

• Have a validation that checks if a system is pre-solvated and still another SolventComponent is defined.
• Figure out how to handle solvation settings in the case of user supplied solvated boxes. Could these be confusing?
• The user will still need a SolventComponent for the solvent leg. Make sure this is not confusing, esp. since ABFE and RBFE handle the different legs in the cycle differently.

Simulation of any other pre-solvated system

User story

• If a user wants to carefully equilibrate the system prior to running RBFE calculations (e.g. equilibrate the binding site water molecule), such a pre-solvated system can currently not be ingested in the RBFE protocol. Even when preequilibrating using our own MD protocol, the output can not be directly ingested into the RBFE protocol.

User experience

• Very similar to the protein-membrane system, the user would provide a solvated protein system (just no lipids), having the ligands and cofactors separately as SmallMoleculeComponents

Hopefully this should automatically be feasible with the new "ProteinComponent" that's needed for the pre-solvated protein-membrane systems, but just to have another use case.