section_1/protein_ligand_complex.ipynb

{
  "cells": [
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "a1WqSEhzrRKO"
      },
      "source": [
        "# Protein Ligand Complex\n",
        "\n",
        "You can run this notebook in your browser: \n",
        "\n",
        "[![Open On Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openmm/openmm_workshops/blob/main/section_1/protein_ligand_complex.ipynb)\n",
        "\n",
        "\n",
        "In this notebook, we will demonstrate two ways of setting up a protein-ligand complex simulation in OpenMM.\n",
        "\n",
        "- **Method 1**\n",
        "\n",
        "  Using the OpenMM package [openmmforcefields](https://github.com/openmm/openmmforcefields) and an external package called Open Force Field toolkit ([openff-toolkit](https://github.com/openforcefield/openff-toolkit)).\n",
        "\n",
        "  This covers the following steps:\n",
        "    - Loading in the ligand with `openff-toolkit`.\n",
        "    - Parameterising the ligand force-field with `openmmforcefields`.\n",
        "    - Combining the topologies.\n",
        "    - Solvating and simulating.\n",
        "\n",
        "  *Note this notebook is based on the [openff-toolkit's example](https://github.com/openforcefield/openff-toolkit/blob/stable/examples/toolkit_showcase/toolkit_showcase.ipynb) . We would like to give credit to the Open ForceField Authors.*\n",
        "\n",
        "- **Method 2**\n",
        "\n",
        "  Using a third party tool ([BioSimSpace](https://biosimspace.openbiosim.org/)) to produce OpenMM-compatible input files.\n",
        "\n",
        "  This covers the following steps:\n",
        "    - Using a BSS workflow to take the protein+ligand files and produce Amber-format input files.\n",
        "    - Using Amber input files with OpenMM.\n",
        "\n",
        "\n",
        "## Table of Contents\n",
        "- Method 1: OpenFF-toolkit\n",
        "  - Extra conda packages\n",
        "  - System\n",
        "  - Load the molecules\n",
        "  - Create the force field\n",
        "  - Combine and solvate\n",
        "  - Simulate\n",
        "- Method 2: BioSimSpace\n",
        "  - Extra conda packages\n",
        "  - BSS Workflow\n",
        "  - Run with OpenMM\n",
        "- Extra exercises\n",
        "- Solutions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Method 1: OpenFF-toolkit \n",
        "<a id=\"method1\"></a>\n",
        "\n",
        "### Extra Packages\n",
        "<a id=\"packages1\"></a>\n",
        "\n",
        "We will need to install the additional python packages:\n",
        "\n",
        " - `openmmforcefields`\n",
        "   - github: https://github.com/openmm/openmmforcefields\n",
        "   - conda-forge: https://anaconda.org/conda-forge/openmmforcefields\n",
        " - `openff-toolkit`\n",
        "   - github: https://github.com/openforcefield/openff-toolkit\n",
        "   - conda-forge: https://anaconda.org/conda-forge/openff-toolkit\n",
        "\n",
        "Both of these will be installed if you install `openmmforcefields` from conda-forge.\n",
        "\n",
        "Note that for apple silicon you may need to create a x86 conda environment see [here](https://github.com/openforcefield/openff-toolkit/blob/main/FAQ.md#im-having-troubles-installing-the-openff-toolkit-on-my-apple-silicon-mac).\n",
        "\n",
        "If you run into problems, we recommend you create a fresh conda environment and install `openmmforcefields` firsts. It is easier for conda to solve dependency issues in fresh environments."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SZyXIEdQrRKS"
      },
      "outputs": [],
      "source": [
        "# Execute this cell to install mamba in the Colab environment and then install openmm\n",
        "\n",
        "if 'google.colab' in str(get_ipython()):\n",
        "    print('Running on colab')\n",
        "    !pip install -q condacolab\n",
        "    import condacolab\n",
        "    condacolab.install_mambaforge()\n",
        "else:\n",
        "    print('Not running on colab.')\n",
        "    print('Make sure you create and activate a new conda environment!')"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "<div class=\"alert alert-block alert-info\">\n",
        "  ⚠️ <b>Note: During this step in Colab, the kernel will restart, which may trigger the error message: \"Your session crashed for an unknown reason.\" This is expected behavior and can be safely ignored.</b>\n",
        "</div>\n",
        "\n",
        "\n",
        "<div class=\"alert alert-block alert-info\">\n",
        "⚠️ <b>Note that the installation will take several minutes!</b>\n",
        "</div>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "T_-_BLwFrRKT"
      },
      "outputs": [],
      "source": [
        "!mamba install -y -c conda-forge openmmforcefields"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "gcfdPKeSrRKU"
      },
      "source": [
        "### Imports\n",
        "\n",
        "We need to be careful with the imports here because OpenMM and OpenFF have some objects with the same names. For this reason, we no longer use wildcard imports and will henceforth adopt a more typical (and recommended) Python programming approach."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kDHjxL6wrRKU"
      },
      "outputs": [],
      "source": [
        "from sys import stdout\n",
        "\n",
        "# OpenMM imports\n",
        "import openmm.app as app\n",
        "import openmm as mm\n",
        "import openmm.unit as unit\n",
        "from openmmforcefields.generators import SMIRNOFFTemplateGenerator\n",
        "\n",
        "# OpenFF-toolkit imports\n",
        "from openff.toolkit import Molecule\n",
        "from openff.toolkit import Topology as offTopology\n",
        "from openff.units.openmm import to_openmm as offquantity_to_openmm"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "rnEI4Fc-rRKU"
      },
      "source": [
        "### System\n",
        "<a id=\"system\"></a>\n",
        "\n",
        "Our example system consists of a complex of a benzene ligand and a lysozyme protein. Lysozyme is an antimicrobial protein that has been extensively studied using MD simulations. We can download the files from the GitHub repository, and we will also download a second ligand (o-xylene) to use in a later exercise."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XWgLx3XYrRKV"
      },
      "outputs": [],
      "source": [
        "# Get the files\n",
        "!wget https://raw.githubusercontent.com/openmm/openmm_workshops/main/section_1/benzene.sdf\n",
        "!wget https://raw.githubusercontent.com/openmm/openmm_workshops/main/section_1/o-xylene.sdf\n",
        "!wget https://raw.githubusercontent.com/openmm/openmm_workshops/main/section_1/lysozyme.pdb"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "The benzene-lysozyme complex is shown in the figure below.\n",
        "\n",
        "![benzene-lysozyme](./images/benzene_lysozyme.png)\n",
        "**Figure 1:** Benzene-lysozyme complex.\n",
        "\n",
        "Note that the files we are using have already been cleaned up (see [PDBFixer](https://github.com/openmm/pdbfixer) for more info). Additionally, the ligand is aligned with the protein and in an appropriate binding site. This is something you would need to do with a docking program before using OpenMM."
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "ME4FZlXwrRKV"
      },
      "source": [
        "\n",
        "### Load in the Molecules\n",
        "<a id=\"load\"></a>\n",
        "\n",
        "The protein structure is given as a PDB file so we can load it as before. The benzene molecule is in SDF file format, for which OpenMM does not have loaders. Therefore, we will we use OpenFF-toolkit to load the ligand.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mUZqalWTrRKW"
      },
      "outputs": [],
      "source": [
        "protein_path = \"lysozyme.pdb\"\n",
        "ligand_path = \"benzene.sdf\"\n",
        "\n",
        "# Load a molecule from a SDF file\n",
        "ligand = Molecule.from_file(ligand_path)\n",
        "\n",
        "# Load the protein from a PDB file\n",
        "protein_pdb = app.PDBFile(protein_path)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "kKdc9iyurRKW"
      },
      "source": [
        "### Creating the ForceField Object\n",
        "\n",
        "<a id=\"createff\"></a>\n",
        "\n",
        "We now need to define the force field to use. For the protein, we can use the standard force fields already available in OpenMM. However, for the benzene molecule, we will need to generate a force field template for it.\n",
        "\n",
        "We can do this by using the residue template generators for small molecules already available from the [openmmforcefields](https://github.com/openmm/openmmforcefields) package. We have the option to choose between the [Amber GAFF small molecule force field](http://ambermd.org/antechamber/gaff.html) or the [Open Force Field Initiative force fields](https://github.com/openforcefield/openff-forcefields).\n",
        "\n",
        "For this example, we will use [OpenFF SMIRNOFF](https://docs.openforcefield.org/projects/toolkit/en/stable/users/smirnoff.html).\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "j6dzzVydrRKW"
      },
      "outputs": [],
      "source": [
        "# Create the SMIRNOFF template generator with the default force field\n",
        "smirnoff = SMIRNOFFTemplateGenerator(molecules=ligand)\n",
        "\n",
        "# We can check which version of the force field is being used\n",
        "print(smirnoff.smirnoff_filename)\n",
        "\n",
        "# Create an OpenMM ForceField object with AMBER ff14SB and TIP3P\n",
        "ff = app.ForceField('amber/protein.ff14SB.xml', 'amber/tip3p_standard.xml')\n",
        "\n",
        "# Add in the SMIRNOFF template generator\n",
        "ff.registerTemplateGenerator(smirnoff.generator)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "lD_4s8narRKW"
      },
      "source": [
        "### Combine Topologies and Solvate the Complex\n",
        "<a id=\"combine\"></a>\n",
        "\n",
        "We can convert from the OpenFF format topology to an OpenMM format topology and then use the OpenMM `Modeller` to combine the ligand and protein into a single topology. Once combined we can solvate as before."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ty2DhYkMrRKW"
      },
      "outputs": [],
      "source": [
        "# Make an OpenMM Modeller object with the protein\n",
        "modeller = app.Modeller(protein_pdb.topology, protein_pdb.positions)\n",
        "\n",
        "# Make an OpenFF Topology of the ligand\n",
        "ligand_off_topology = offTopology.from_molecules(molecules=[ligand])\n",
        "\n",
        "# Convert it to an OpenMM Topology\n",
        "ligand_omm_topology = ligand_off_topology.to_openmm()\n",
        "\n",
        "# Get the positions of the ligand\n",
        "ligand_positions = offquantity_to_openmm(ligand.conformers[0])\n",
        "\n",
        "# Add the ligand to the Modeller\n",
        "modeller.add(ligand_omm_topology, ligand_positions)\n",
        "\n",
        "# Solvate\n",
        "modeller.addSolvent(ff, padding=1.0*unit.nanometer, ionicStrength=0.15*unit.molar)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "Vi8r-JjurRKX"
      },
      "source": [
        "### Simulate\n",
        "<a id=\"simulate1\"></a>\n",
        "\n",
        "We can now simulate in the NVT ensemble as before.\n",
        "\n",
        "<div class=\"alert alert-block alert-info\">\n",
        "ℹ️ <b>Exercise 1</b>\n",
        "\n",
        "Set the initial positions of the simulation.\n",
        "</div>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cWmDX1ZkrRKX"
      },
      "outputs": [],
      "source": [
        "# Create the system, define the integrator, and create the simulation\n",
        "system = ff.createSystem(modeller.topology, nonbondedMethod=app.PME, constraints=app.HBonds)\n",
        "integrator = mm.LangevinMiddleIntegrator(300*unit.kelvin, 1/unit.picosecond, 0.002*unit.picoseconds)\n",
        "simulation = app.Simulation(modeller.topology, system, integrator)\n",
        "\n",
        "# set the positions\n",
        "FIXME\n",
        "\n",
        "print(\"Minimizing energy...\")\n",
        "simulation.minimizeEnergy(maxIterations=100)\n",
        "\n",
        "simulation.context.setVelocitiesToTemperature(300*unit.kelvin)\n",
        "\n",
        "simulation.reporters.append(app.PDBReporter('traj.pdb', 100))\n",
        "\n",
        "simulation.reporters.append(app.StateDataReporter(stdout, 100, step=True,\n",
        "        potentialEnergy=True, temperature=True, speed=True))\n",
        "\n",
        "print(\"Running simulation...\")\n",
        "simulation.step(1000)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "<div class=\"alert alert-block alert-info\">\n",
        "ℹ️ <b>Exercise 2</b>\n",
        "\n",
        "Download the `traj.pdb` file and visualize it. You will need to click on the `files` icon on the left side bar of the Colab window:\n",
        "\n",
        "![screenshot](images/screenshot1.png)\n",
        "</div>"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "When you open `traj.pdb` in VMD, it should look similar to this:\n",
        "\n",
        "![screenshot_traj](images/screenshot3.png)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "The protein appears to be sticking out of the side of the water box. This is just a visualization artifact due to the periodic boundary conditions. By default, OpenMM wraps the coordinates to keep molecules whole. For more information, read the OpenMM FAQs on this topic: https://github.com/openmm/openmm/wiki/Frequently-Asked-Questions#periodic."
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "y0-CqTRrrRKX"
      },
      "source": [
        "## Method 2\n",
        "<a id=\"method2\"></a>\n",
        "\n",
        "In this method, we will use a [BioSimSpace](https://biosimspace.openbiosim.org/) (BSS) workflow to produce [Amber](https://ambermd.org/)-format input files that we can read into OpenMM.\n",
        "\n",
        "### Extra Packages\n",
        "<a id=\"packages2\"></a>\n",
        "\n",
        "We need to install [BioSimSpace from the OpenBioSim channel](https://anaconda.org/openbiosim/biosimspace)\n",
        "\n",
        "The conda command below instructs conda to search for `biosimspace` in the `openbiosim` and `conda-forge` channels, along with the optional for BSS but necessary dependencies for this specific workflow, `gromacs` and `ambertools`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Kg1zkciHrRKX"
      },
      "outputs": [],
      "source": [
        "if 'google.colab' in str(get_ipython()):\n",
        "    # https://github.com/googlecolab/colabtools/issues/3409\n",
        "    import locale\n",
        "    locale.getpreferredencoding = lambda: \"UTF-8\"\n",
        "\n",
        "!mamba install -y -c conda-forge -c openbiosim biosimspace  gromacs ambertools"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "MPVw4HaurRKX"
      },
      "source": [
        "### Get the BSS Workflow\n",
        "<a id=\"bssworkflow\"></a>\n",
        "\n",
        "We will use a BSS workflow (also called a Node) which takes in the ligand SDF file along with protein PDB file and combines them into a protein-ligand complex solvated in a water box. A BSS node is a python script that can be run as a command line program. We will use the script in this workshop repo which is based on an [example script from BioSimSpace](https://github.com/michellab/BioSimSpace/blob/6a36648e1f2e95ee6de35b2e6c9ac32f201c2bc8/nodes/playground/BSSPrepNode.ipynb). For more information please look at the [BioSimSpace documentation](https://biosimspace.openbiosim.org/)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "t-BJ7vqyrRKX"
      },
      "outputs": [],
      "source": [
        "# get the BSS workflow\n",
        "!wget https://raw.githubusercontent.com/openmm/openmm_workshops/main/section_1/BSSPrepNode.py"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "2uyN1jjArRKX"
      },
      "source": [
        "### Run the workflow\n",
        "\n",
        "If you run the script without any command line arguments, it will print out help info."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HmCXM5iZrRKX"
      },
      "outputs": [],
      "source": [
        "!python BSSPrepNode.py"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "iDhNG0ZRrRKX"
      },
      "source": [
        "We can then run it specifying the ligand and protein files with command line arguments. \n",
        "\n",
        "If you get the error *\"MissingSoftwareError: 'BioSimSpace.Parameters.gaff2' is not supported. Please \n",
        "install AmberTools (http://ambermd.org).\"* but you have already installed AmberTools with conda then you will need to set the environmental variable `AMBERHOME` to the install location. The first cell below will do it correctly for running on Colab. On your own device it will be different."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LDFS-B_3rRKY"
      },
      "outputs": [],
      "source": [
        "if 'google.colab' in str(get_ipython()):\n",
        "  import os\n",
        "  os.environ[\"AMBERHOME\"]=\"/usr/local/\"\n",
        "else:\n",
        "  print('You might need to set AMBERHOME env variable')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "!python BSSPrepNode.py --ligand benzene.sdf --protein lysozyme.pdb"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "mIsaIYZDrRKY"
      },
      "source": [
        "It will produce the files:\n",
        " - `bound.prm7` - the Amber topology file for the protein-ligand complex.\n",
        " - `bound.rst7` - the Amber coordinate file for the protein-ligand complex.\n",
        "\n",
        "it also produces `free.prm7` and `free.rst7` which are the input files for just the ligand solvated in a water box. These would be used in thermodynamic cycle calculations to compute binding energies."
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Run with OpenMM\n",
        "<a id=\"run\"></a>\n",
        "\n",
        "OpenMM has the capability to load [Amber format files](http://docs.openmm.org/latest/userguide/application/02_running_sims.html#using-amber-files). `AmberPrmtopFile` can load the topology file and `AmberInpcrdFile` can load in the coordinates. The rest of the setup is very similar to using PDB files. Note that we do not need to define a forcef ield as this is included in the Amber topology file, so we simply call `prmtop.createSystem` instead of `ff.createSystem`.\n",
        "\n",
        "<div class=\"alert alert-block alert-info\">\n",
        "ℹ️ <b>Exercise 3</b>\n",
        "\n",
        "Specify the OpenMM integrator.\n",
        "</div>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cjLSMG1krRKY"
      },
      "outputs": [],
      "source": [
        "import openmm.app as app\n",
        "import openmm as mm\n",
        "import openmm.unit as unit\n",
        "from sys import stdout\n",
        "\n",
        "prmtop = app.AmberPrmtopFile('bound.prm7')\n",
        "inpcrd = app.AmberInpcrdFile('bound.rst7')\n",
        "system = prmtop.createSystem(nonbondedMethod=app.PME, nonbondedCutoff=1*unit.nanometer,\n",
        "        constraints=app.HBonds)\n",
        "\n",
        "# Specify the integrator\n",
        "integrator = FIXME\n",
        "\n",
        "simulation = app.Simulation(prmtop.topology, system, integrator)\n",
        "simulation.context.setPositions(inpcrd.positions)\n",
        "simulation.context.setVelocitiesToTemperature(300*unit.kelvin)\n",
        "\n",
        "print(\"Minimizing energy...\")\n",
        "simulation.minimizeEnergy(maxIterations=100)\n",
        "\n",
        "simulation.reporters.append(app.PDBReporter('bss_traj.pdb', 100))\n",
        "simulation.reporters.append(app.StateDataReporter(stdout, 100, step=True,\n",
        "        potentialEnergy=True, temperature=True))\n",
        "\n",
        "print(\"Running simulation...\")\n",
        "simulation.step(1000)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "<div class=\"alert alert-block alert-info\">\n",
        "ℹ️ <b>Exercise 4</b>\n",
        "\n",
        "Download `bss_traj.pdb` and visulize it in VMD or similar software. How does it look different to the `traj.pdd` generated in the previous method?\n",
        "</div>"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "F7m3gIJ2rRKY"
      },
      "source": [
        "## Extra Exercises\n",
        "<a id=\"extraex\"></a>\n",
        "\n",
        "<div class=\"alert alert-block alert-info\">\n",
        "ℹ️ <b>Exercise 5</b>\n",
        "\n",
        "Modify both methods to run in the NPT ensemble.\n",
        "</div>\n",
        "\n",
        "<div class=\"alert alert-block alert-info\">\n",
        "ℹ️ <b>Exercise 6</b>\n",
        "\n",
        "Run both setups again using using the o-xylene ligand.\n",
        "</div>\n",
        "\n",
        "<div class=\"alert alert-block alert-info\">\n",
        "ℹ️ <b>Exercise 7</b>\n",
        "\n",
        "Use the command line arguments of `BSSPrepNode.py` to specify a different force field.\n",
        "</div>\n",
        "\n",
        "<div class=\"alert alert-block alert-info\">\n",
        "ℹ️ <b>Exercise 8</b>\n",
        "\n",
        "Take a look at the `BSSPrepNode.py` file in a text editor. Can you modify it to only output the bound state?\n",
        "</div>\n",
        "\n",
        "<div class=\"alert alert-block alert-info\">\n",
        "ℹ️ <b>Exercise 9</b>\n",
        "\n",
        "Create a modified version of Method 1 to run a simulation of just the ligand in a water box.\n",
        "</div>"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Solutions\n",
        "<a id=\"solutions\"></a>\n",
        "\n",
        "*Exercise 1*. Set the initial positions:\n",
        "```python\n",
        "simulation.context.setPositions(modeller.positions)\n",
        "```\n",
        "\n",
        "*Exercise 3*. Specify the integrator:\n",
        "```python\n",
        "integrator = mm.LangevinMiddleIntegrator(300*unit.kelvin, 1/unit.picosecond, 0.002*unit.picoseconds)\n",
        "```\n",
        "\n",
        "*Exercise 4*. In `bss_traj.pdb`, the protein is centered within the water box, whereas in `traj.pdb`, it appears off to the side. This difference is a result of the visualization effects of periodic boundaries. Additionally, the water boxes have different dimensions due to variations in the setup steps."
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "openff",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.9.16"
    },
    "orig_nbformat": 4
  },
  "nbformat": 4,
  "nbformat_minor": 0
}