GROMACS_for_production.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "private_outputs": true,
      "provenance": [],
      "collapsed_sections": [
        "vv5cq2Wv7UhB",
        "DgDM_9EPTm-o",
        "j7tcSeX0b5dd"
      ],
      "gpuType": "T4",
      "machine_shape": "hm"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "#### GROMACS for production <font color=\"DarkSeaGreen\">/ GROMACS-on-Colab</font> [<img src=\"https://github.githubassets.com/favicons/favicon.png\" width=\"16\">](https://github.com/bioinfkaustin/gromacs-on-colab)\n",
        "<small>Suite: [`Build_to_Google_Drive.ipynb`](https://colab.research.google.com/github/bioinfkaustin/gromacs-on-colab/blob/main/Build_to_Google_Drive.ipynb) | [`GROMACS_for_CHARMM-GUI.ipynb`](https://colab.research.google.com/github/bioinfkaustin/gromacs-on-colab/blob/main/GROMACS_for_CHARMM-GUI.ipynb) | `GROMACS_for_production.ipynb` | [`Trajectory_analysis_tools.ipynb`](https://colab.research.google.com/github/bioinfkaustin/gromacs-on-colab/blob/main/Trajectory_analysis_tools.ipynb)</small>"
      ],
      "metadata": {
        "id": "4zwSgdGDP9cV"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Documentation\n",
        "Please click ***↳ cells hidden*** below to show the documentation for this notebook."
      ],
      "metadata": {
        "id": "vv5cq2Wv7UhB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### License\n",
        "\n",
        "> This notebook as a work of software is licensed under the terms of the [AGPL-3.0](https://opensource.org/licenses/AGPL-3.0) or later."
      ],
      "metadata": {
        "id": "5dTAvj38Dal8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### About this software\n",
        "\n",
        "> This notebook runs or extends a **GROMACS production simulation**.\n",
        ">\n",
        "> It operates within a **project folder** containing the initial condition `conf.gro`, the topology `topol.top` (and probably `toppar/`), and the simulation parameters file `grompp.mdp` alongside its prerequisites (the group labels `index.ndx` and so on).\n",
        ">\n",
        "> All inputs must have the [GROMACS default names](https://manual.gromacs.org/current/onlinehelp/gmx-grompp.html) (e.g. if you need to provide reference coordinates for restraints, a file called `restraint.gro` must be present)."
      ],
      "metadata": {
        "id": "Jb0ESikELkRH"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Installation\n",
        "\n",
        "> The installation notebook, [`Build_to_Google_Drive.ipynb`](https://colab.research.google.com/github/bioinfkaustin/gromacs-on-colab/blob/main/Build_to_Google_Drive.ipynb), must be run before using this notebook."
      ],
      "metadata": {
        "id": "Cl4YtmH7mICa"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Configuration"
      ],
      "metadata": {
        "id": "1pWciuVhQCYo"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Pm9Dk5FBDoF4",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import re\n",
        "import shutil\n",
        "\n",
        "#@markdown Specify the location of the **GROMACS project folder** to simulate. It should contain `conf.gro` and `topol.top` (and probably `toppar/`), the simulation parameters file `grompp.mdp`, and any optional input files required by those parameters (such as `index.ndx` or `restraint.gro`).\n",
        "project_folder = \"{GoogleDrive}/GROMACS/7FBF_FABPH_vs_octanoic_acid\" #@param {type: \"string\"}\n",
        "# default: {GoogleDrive}/GROMACS/7FBF_FABPH_vs_octanoic_acid\n",
        "\n",
        "#@markdown Choose for how long the simulation should run.\n",
        "simulation_duration_ns = 10 #@param {type: \"integer\"}\n",
        "# default: 10\n",
        "\n",
        "#@markdown Provide a unique filename prefix for this simulation.\n",
        "output_prefix = \"sim\" #@param {type: \"string\"}\n",
        "# default: sim\n",
        "\n",
        "#@markdown If applicable, please see also the advanced settings below. **After filling in this form, run the notebook by clicking *Runtime -> Run all* in the toolbar.**\n",
        "\n",
        "#@markdown \\\n",
        "#@markdown **Early stopping**\n",
        "#@markdown\n",
        "#@markdown Optionally, a group may be specified for which the RMSD from the initial conformation should be monitored. The run stops if a threshold RMSD (Angstroms) is exceeded for 0.5 ns.\n",
        "rmsd_group = \"LIG\" #@param {type: \"string\"}\n",
        "rmsd_early_stop_threshold_A = 12.0 #@param {type: \"number\"}\n",
        "# default: 12.0\n",
        "\n",
        "\n",
        "#\n",
        "# Google Drive\n",
        "#\n",
        "\n",
        "if not os.path.isdir(\"/content/drive/MyDrive\"):\n",
        "  from google.colab import drive\n",
        "  drive.mount(\"/content/drive\")\n",
        "\n",
        "if not os.path.isdir(\"/content/drive/MyDrive\"):\n",
        "  raise RuntimeError(\"Error: could not connect to Google Drive\")\n",
        "\n",
        "\n",
        "#\n",
        "# Validate the input values\n",
        "#\n",
        "\n",
        "def _path(s, exists=False):\n",
        "  if \"{GoogleDrive}\" in s and not s.startswith(\"{GoogleDrive}\"):  raise ValueError(f\"Error: {{GoogleDrive}} is a path prefix, but appears later: {s}\")\n",
        "  s = s.format(GoogleDrive=\"/content/drive/MyDrive\")\n",
        "  #     ^^^ raises KeyError if any {...} placeholder is present except {GoogleDrive}\n",
        "\n",
        "  if exists  and not os.path.isdir(s):  raise FileNotFoundError(f\"Error: folder not found: {s}\")\n",
        "  return os.path.abspath(s)\n",
        "\n",
        "def parse(s, mandatory=False, path=False, exists=False):\n",
        "  s = s.strip()\n",
        "  # error on e.g. \"\"\n",
        "  if mandatory and not s:\n",
        "    raise ValueError(\"Error: mandatory setting without value\")\n",
        "  # e.g. {GoogleDrive}/archive.tgz -> /content/drive/MyDrive/archive.tgz\n",
        "  if path:\n",
        "    s = _path(s, exists=exists)\n",
        "  return s\n",
        "\n",
        "\n",
        "# project_folder\n",
        "\n",
        "project_folder = parse(project_folder, mandatory=True, path=True, exists=True)\n",
        "\n",
        "\n",
        "# simulation_duration_ns\n",
        "\n",
        "if simulation_duration_ns <= 0:\n",
        "  raise RuntimeError(f\"Error: simulation duration must be more than 0 ns, but got: {simulation_duration_ns} ns\")\n",
        "\n",
        "simulation_duration_ps = 1000 * simulation_duration_ns\n",
        "\n",
        "\n",
        "# output_prefix\n",
        "\n",
        "output_prefix = output_prefix.strip()\n",
        "\n",
        "if not output_prefix:\n",
        "  raise RuntimeError(\"Error: an output prefix must be provided\")\n",
        "\n",
        "if not re.match(r\"^[0-9a-zA-Z]+$\", output_prefix):\n",
        "  raise RuntimeError(f\"Error: special characters are not allowed in output prefix, but got: {output_prefix}\")\n",
        "\n",
        "if output_prefix in (\"dat\", \"pre\", \"lig\"):\n",
        "  raise RuntimeError(f\"Error: reserved output prefix: {output_prefix}\")\n",
        "\n",
        "\n",
        "# rmsd_group\n",
        "\n",
        "rmsd_group = rmsd_group.strip()\n",
        "\n",
        "\n",
        "# rmsd_early_stop_threshold\n",
        "\n",
        "if rmsd_early_stop_threshold_A is None:\n",
        "  rmsd_early_stop_threshold_A = 0.0\n",
        "\n",
        "rmsd_early_stop_threshold_nm = rmsd_early_stop_threshold_A / 10.\n",
        "\n",
        "\n",
        "#\n",
        "# Make sure that the notebook is in the start folder\n",
        "#\n",
        "\n",
        "if \"START\" not in os.environ or not os.environ[\"START\"]:\n",
        "  %env START={os.getcwd()}\n",
        "else:\n",
        "  %cd {os.environ[\"START\"]}\n",
        "\n",
        "\n",
        "#\n",
        "# Use a clean scratch directory for the rest of the run\n",
        "#\n",
        "\n",
        "try:\n",
        "  shutil.rmtree(\"scratch\")\n",
        "except FileNotFoundError:\n",
        "  pass\n",
        "os.makedirs(\"scratch\")\n",
        "%cd \"scratch\""
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Input"
      ],
      "metadata": {
        "id": "DgDM_9EPTm-o"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%bash -s \"$project_folder\" \"$output_prefix\"\n",
        "project_folder=\"$1\"\n",
        "output_prefix=\"$2\"\n",
        "#@markdown Extract the system from the project folder.\n",
        "\n",
        "if [[ ! -z \"$(ls -A)\" ]]; then\n",
        "  exit 0  # already extracted\n",
        "fi\n",
        "\n",
        "if [[ ! -d \"${project_folder}\" ]]; then\n",
        "  echo \"Error: folder not found: ${project_folder}\" >&2\n",
        "  exit 1\n",
        "fi\n",
        "\n",
        "pushd \"${project_folder}\"\n",
        "\n",
        "cp \"grompp.mdp\"  \"conf.gro\"  \"restraint.gro\"  \"index.ndx\"  \"topol.top\"  \"${START}/scratch/\" 2> /dev/null\n",
        "\n",
        "top_level_dir=\"$(realpath .)\"\n",
        "function get_includes_recursively {\n",
        "  f=\"$1\"\n",
        "  sed -E \"/^#include/!d; s/^#include +['\\\"]//; s/['\\\"]$//\" \"${f}\" | while read -r g; do\n",
        "    d=\"$(dirname \"${g}\")\"\n",
        "    b=\"$(basename \"${g}\")\"\n",
        "    pushd \"${d}\" > /dev/null\n",
        "    get_includes_recursively \"${b}\"\n",
        "    echo \"$(realpath --relative-to=\"${top_level_dir}\" \"${b}\")\"\n",
        "    popd > /dev/null\n",
        "  done\n",
        "}\n",
        "get_includes_recursively \"topol.top\" | while read -r f; do\n",
        "  cp --parents \"${f}\" \"${START}/scratch/\"\n",
        "done\n",
        "\n",
        "i=1\n",
        "part=\"$(printf \"part%04i\" \"$i\")\"\n",
        "while [[ -s \"${output_prefix}.${part}.tar.gz\" ]]; do\n",
        "  if gunzip --test \"${output_prefix}.${part}.tar.gz\"; then\n",
        "    tar -xzf \"${output_prefix}.${part}.tar.gz\" -C \"${START}/scratch\"\n",
        "  else\n",
        "    echo \"Warning: corrupted part file: ${output_prefix}.${part}.tar.gz\" >&2\n",
        "    break\n",
        "  fi\n",
        "\n",
        "  i=$(($i + 1))\n",
        "  part=\"$(printf \"part%04i\" \"$i\")\"\n",
        "done\n",
        "\n",
        "popd\n",
        "\n",
        "if [[ ! -s \"grompp.mdp\" || ! -s \"conf.gro\" || ! -s \"topol.top\" ]]; then\n",
        "  echo \"Error: essential files not found: grompp.mdp, conf.gro, topol.top\" >&2\n",
        "  exit 1\n",
        "fi"
      ],
      "metadata": {
        "cellView": "form",
        "id": "H-_SROb49vPu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Installation"
      ],
      "metadata": {
        "id": "j7tcSeX0b5dd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown In the following cells, applications are downloaded from a **persistent cache** in your Google Drive.\n",
        "#@markdown\n",
        "#@markdown This cell sets up the cache folder.\n",
        "\n",
        "storage = \"/content/drive/MyDrive/gromacs-on-colab\"\n",
        "%env STORAGE={storage}"
      ],
      "metadata": {
        "cellView": "form",
        "id": "DHCCcg4Mlk0J"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "%%bash\n",
        "#@markdown **GROMACS** is installed from cache.\n",
        "\n",
        "if [[ -d \"/usr/local/gromacs\" ]]; then\n",
        "  exit 0  # already installed\n",
        "fi\n",
        "\n",
        "gromacs_vers=\"2023.2\" #@param {type: \"string\"}\n",
        "cache_gromacs=\"${STORAGE}/gromacs-${gromacs_vers}.tar.gz\"\n",
        "\n",
        "if [[ -s \"${cache_gromacs}\" ]]; then\n",
        "  tar -xzf \"${cache_gromacs}\" -C \"/usr/local\"\n",
        "else\n",
        "  echo \"Error: GROMACS installation not found\" >&2\n",
        "  echo \"(Have you installed GROMACS to your Google Drive?)\" >&2\n",
        "  exit 1\n",
        "fi"
      ],
      "metadata": {
        "cellView": "form",
        "id": "YLXFoaDzlmqv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Simulation"
      ],
      "metadata": {
        "id": "CW5PS8lCuDS1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%writefile \"run.bash\"\n",
        "project_folder=\"$1\"\n",
        "simulation_duration_ps=$2\n",
        "rmsd_group=\"$3\"\n",
        "rmsd_early_stop_threshold_nm=$4\n",
        "prefix=\"$5\"\n",
        "#@markdown Create a script to run the production simulation.\n",
        "\n",
        "source \"/usr/local/gromacs/bin/GMXRC.bash\"\n",
        "export GMX_MAXCONSTRWARN=-1\n",
        "\n",
        "export GMX_CUDA_GRAPH=1  # experimental upgrade\n",
        "\n",
        "{\n",
        "  echo \"***\"\n",
        "  echo \"${project_folder}\"\n",
        "  date \"+%F %T\"\n",
        "  echo \"---\"\n",
        "  echo \"$(nproc) cores, $(free -m | awk 'NR == 2 { print $2 }') MiB\"\n",
        "  nvidia_smi=\"$(nvidia-smi --query-gpu=\"name,memory.total\" --format=\"csv,noheader\")\"\n",
        "  if (( $? == 0 )); then\n",
        "    echo \"$nvidia_smi\"\n",
        "  fi\n",
        "  echo \"***\"\n",
        "  echo \"\"\n",
        "} | tee -a \"${prefix}.summary\"\n",
        "\n",
        "# Get the runtime of each individual run\n",
        "sim_dt=$(awk '$1 == \"dt\" { print $3 }' \"grompp.mdp\")\n",
        "sim_nsteps=$(awk '$1 == \"nsteps\" { print $3 }' \"grompp.mdp\")\n",
        "block_ps=$(perl -e \"printf(\\\"%.0f\\n\\\", ${sim_dt} * ${sim_nsteps})\")\n",
        "\n",
        "# Is this the first ever run?\n",
        "if [[ -s \"${prefix}.cpt\" ]]; then\n",
        "  skip_because_continuation=true\n",
        "else\n",
        "\n",
        "  skip_because_continuation=false\n",
        "\n",
        "  # Construct the `gmx grompp ...` command\n",
        "  cmd=( gmx grompp -f \"grompp.mdp\" -o \"${prefix}.tpr\" -c \"conf.gro\" -p \"topol.top\" -maxwarn 999 )\n",
        "  if [[ -s \"restraint.gro\" ]]; then\n",
        "    cmd+=( -r \"restraint.gro\" )\n",
        "  fi\n",
        "  if [[ -s \"index.ndx\" ]]; then\n",
        "    cmd+=( -n \"index.ndx\" )\n",
        "  fi\n",
        "\n",
        "  # Run `gmx grompp ...`\n",
        "  \"${cmd[@]}\"\n",
        "\n",
        "\n",
        "  #\n",
        "  # Run a block of the simulation with `gmx mdrun ...`\n",
        "  #\n",
        "\n",
        "  {\n",
        "    echo \"Block: 0 ps to ${block_ps} ps / ${simulation_duration_ps} ps\"\n",
        "    date \"+%F %T\"\n",
        "    echo \"\"\n",
        "  } | tee -a \"${prefix}.summary\"\n",
        "\n",
        "  gmx mdrun -v -stepout 1000 -deffnm \"${prefix}\" -noappend -bonded gpu  ||  exit $?\n",
        "  #                                            abort if GROMACS crashed ^^^^^^^^^^^\n",
        "\n",
        "fi\n",
        "\n",
        "[[ -s \"${prefix}.part0001.trr\" ]] && trr_frames=\"$(gmx check -f \"${prefix}.part0001.trr\" 2>&1 | awk '$1 ~ /^Coords/ { print $2 }')\" || trr_frames=0\n",
        "[[ -s \"${prefix}.part0001.xtc\" ]] && xtc_frames=\"$(gmx check -f \"${prefix}.part0001.xtc\" 2>&1 | awk '$1 ~ /^Coords/ { print $2 }')\" || xtc_frames=0\n",
        "if (( $trr_frames == 0 && $xtc_frames == 0 )); then\n",
        "  echo \"Error: no trajectory found: ${prefix}.part0001.xtc or ${prefix}.part0001.trr\" >&2\n",
        "  exit 0\n",
        "elif (( $trr_frames >= $xtc_frames )); then\n",
        "  xtcext=\"trr\"\n",
        "  ndecarg=\"-ndec 4\"\n",
        "else\n",
        "  xtcext=\"xtc\"\n",
        "  ndecarg=\"\"\n",
        "fi\n",
        "\n",
        "while true; do\n",
        "\n",
        "  latest_part=\"$(ls | egrep '^'\"${prefix}\"'\\.part[0-9]+\\.log$' | sort -V | tail -n1 | egrep -o 'part[0-9]+')\"\n",
        "\n",
        "  if $skip_because_continuation; then\n",
        "    skip_because_continuation=false\n",
        "  else\n",
        "\n",
        "    # Save useful performance information to the summary file\n",
        "    {\n",
        "      grep \"^Performance: \" -B3 -A1 \"${prefix}.${latest_part}.log\"\n",
        "      echo \"\"\n",
        "    } | tee -a \"${prefix}.summary\"\n",
        "\n",
        "    # Upload an archive with the latest relevant information\n",
        "    tar -vczf \"${prefix}.${latest_part}.tar.gz\" \"${prefix}.summary\" \"${prefix}.tpr\" \"${prefix}.cpt\" \"${prefix}.${latest_part}.\"*\n",
        "    cp \"${prefix}.${latest_part}.tar.gz\" \"${project_folder}/\"\n",
        "\n",
        "  fi\n",
        "\n",
        "  # Get the current total time of the simulation\n",
        "  gmx trjconv -f \"${prefix}.${latest_part}.${xtcext}\" -s \"${prefix}.tpr\" -dump 999999999999 -o \"last.gro\" <<< \"0\"\n",
        "  t=$(($(head -n1 \"last.gro\" | egrep -o 't= [0-9]+' | sed 's/^t= //')))\n",
        "  if [[ -z \"$t\" ]] || (( $t == 0 )); then\n",
        "    echo \"Error: could not read time from trajectory\" >&2\n",
        "    exit 1\n",
        "  fi\n",
        "  rm \"last.gro\"\n",
        "\n",
        "  # Does this exceed the target time? If so, quit\n",
        "  if (( $t >= $simulation_duration_ps )); then\n",
        "    {\n",
        "      echo \"Detected: current simulation time ${t} ps exceeded target time ${simulation_duration_ps} ps\"\n",
        "      echo \"\"\n",
        "    } | tee -a \"${prefix}.summary\"\n",
        "    break\n",
        "  fi\n",
        "\n",
        "  # Get RMSD of specified group\n",
        "  if [[ ! -z \"${rmsd_group}\" && ! -z \"${rmsd_early_stop_threshold_nm}\" ]] && perl -e \"${rmsd_early_stop_threshold_nm} > 0.001 ? exit 0 : exit 1\"; then\n",
        "    gmx trjconv -s \"${prefix}.tpr\" -f \"${prefix}.${latest_part}.${xtcext}\" -pbc nojump -o \"nojump.xtc\" <<< 0\n",
        "\n",
        "    gmx rms -s \"${prefix}.tpr\" -f \"nojump.xtc\" -b $(($t - $block_ps)) < <(echo \"C-alpha\"; echo \"${rmsd_group}\")\n",
        "    rmsd_steps=$(sed '/^[#@&]/d; /^ *$/d' \"rmsd.xvg\" | wc -l)\n",
        "    rmsd_alarm=$(sed '/^[#@&]/d; /^ *$/d' \"rmsd.xvg\" | awk \"\\$2 > ${rmsd_early_stop_threshold_nm}\" | wc -l)\n",
        "\n",
        "    rm \"nojump.xtc\"\n",
        "\n",
        "    # Does this exceed the threshold RMSD? If so, quit\n",
        "    if perl -e \"$rmsd_alarm > $rmsd_steps / 2 ? exit 0 : exit 1\"; then\n",
        "      {\n",
        "        echo \"Detected: RMSD of ${rmsd_group} exceeded threshold ${rmsd_early_stop_threshold_nm} nm\"\n",
        "        echo \"\"\n",
        "      } | tee -a \"${prefix}.summary\"\n",
        "      break\n",
        "    fi\n",
        "  fi\n",
        "\n",
        "\n",
        "  #\n",
        "  # Run another block of the simulation\n",
        "  #\n",
        "\n",
        "  {\n",
        "    echo \"Block: ${t} ps to $((${t} + ${block_ps})) ps / ${simulation_duration_ps} ps\"\n",
        "    date \"+%F %T\"\n",
        "    echo \"\"\n",
        "  } | tee -a \"${prefix}.summary\"\n",
        "\n",
        "  gmx convert-tpr -s \"${prefix}.tpr\" -extend $block_ps -o \"tprout.tpr\"\n",
        "  mv \"tprout.tpr\" \"${prefix}.tpr\"\n",
        "\n",
        "  gmx mdrun -cpi \"${prefix}.cpt\" -v -stepout 1000 -deffnm \"${prefix}\" -noappend -bonded gpu  ||  exit $?\n",
        "  #                                                                 abort if GROMACS crashed ^^^^^^^^^^^\n",
        "\n",
        "done\n",
        "\n",
        "{\n",
        "  echo \"***\"\n",
        "  echo \"End\"\n",
        "  date \"+%F %T\"\n",
        "  echo \"***\"\n",
        "  echo \"\"\n",
        "} | tee -a \"${prefix}.summary\"\n",
        "\n",
        "cp \"${prefix}.summary\" \"${project_folder}/${prefix}_reference.summary\"\n",
        "\n",
        "\n",
        "#\n",
        "# Create a \"reference\" trajectory, suited for human interpretation\n",
        "#\n",
        "\n",
        "gmx trjcat -f \"${prefix}.part\"*\".${xtcext}\" -o \"${prefix}.${xtcext}\"\n",
        "\n",
        "gmx trjconv -f \"${prefix}.${xtcext}\" -s \"${prefix}.tpr\" -pbc nojump $ndecarg -o \"nojump.xtc\" <<< \"0\"\n",
        "\n",
        "gmx trjconv -f \"nojump.xtc\" -s \"${prefix}.tpr\" -fit progressive $ndecarg -o \"progressive.xtc\" < <(echo \"C-alpha\"; echo \"0\")\n",
        "\n",
        "gmx trjconv -f \"progressive.xtc\" -s \"${prefix}.tpr\" -pbc mol $ndecarg -o \"${prefix}_reference.xtc\" <<< \"0\"\n",
        "\n",
        "cp \"${prefix}_reference.xtc\" \"${project_folder}/\"\n",
        "\n",
        "rm \"nojump.xtc\" \"progressive.xtc\"\n",
        "\n",
        "\n",
        "######\n",
        "exit 0"
      ],
      "metadata": {
        "cellView": "form",
        "id": "7XLh47M915GD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown Execute the simulation script.\n",
        "#@markdown\n",
        "#@markdown Run a loop of blocks (typically 1 ns) until the **production simulation** is complete -- each loop iteration saves a partial output.\n",
        "!bash \"run.bash\" \"$project_folder\" \"$simulation_duration_ps\" \"$rmsd_group\" \"$rmsd_early_stop_threshold_nm\" \"$output_prefix\"\n",
        "!sleep 10"
      ],
      "metadata": {
        "id": "1eeGZPavxbQG",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@markdown Finally, disconnect the runtime. (This option is ignored if the project folder is not in your Google Drive.)\n",
        "disconnect = True #@param {type: \"boolean\"}\n",
        "\n",
        "if disconnect and project_folder.startswith(\"/content/drive/MyDrive/\"):\n",
        "  from google.colab import drive, runtime\n",
        "  drive.flush_and_unmount()\n",
        "  runtime.unassign()"
      ],
      "metadata": {
        "id": "QCfsHZdbxNAv",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}