MD-Water.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8178984f-c7a9-40a7-8b8b-5c40c2034f17",
   "metadata": {},
   "source": [
    "# Investigating the Dynamics of Water with Classical Molecular Dynamics Simulations\n",
    "\n",
    "This notebook was designed for the final project of an upper level Condensed Matter Physics course taught at Bryn Mawr College. It was inspired by the Making It Rain Project (Arantes P.R., Depólo Polêto M., Pedebos C., Ligabue-Braun R. Making it rain: cloud-based molecular simulations for everyone. Journal of Chemical Information and Modeling 2021. DOI: 10.1021/acs.jcim.1c00998. https://github.com/pablo-arantes/making-it-rain)\n",
    "\n",
    "This github repository for this project is located here, along with the pdf of the final project document: https://github.com/andrewsb8/Water-Dynamics-MD"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8daa0c30-dc00-4e37-8c62-75add5dd0fd3",
   "metadata": {},
   "source": [
    "## 0  Setting up the Python Environment for Molecular Dynamics Simulations. \n",
    "\n",
    "First, we need to install all necessary libraries and packages for our simulation. The main packages we will be installing are:\n",
    "\n",
    "Anaconda (https://docs.conda.io/en/latest/miniconda.html)  \n",
    "OpenMM (https://openmm.org/)  \n",
    "MDAnalysis (https://www.mdanalysis.org/)  \n",
    "Numpy (https://numpy.org/)  \n",
    "Pandas (https://pandas.pydata.org/)  \n",
    "Matplotlib (https://matplotlib.org/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "603eda02-c899-46b9-9178-5528babe66e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title ### **Import Google Drive**\n",
    "#@markdown Click the \"Run\" buttom to make your Google Drive accessible. Only run this command if in Google Colab!\n",
    "from google.colab import drive\n",
    "\n",
    "drive.flush_and_unmount()\n",
    "drive.mount('/content/drive', force_remount=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0762c2b9-185f-440c-9563-080465a7ffaf",
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title ### **Add some directories to Google Drive for Organization**\n",
    "\n",
    "#import is a workaround for an encoding error: https://github.com/googlecolab/colabtools/issues/3409\n",
    "import locale\n",
    "locale.getpreferredencoding = lambda: \"UTF-8\"\n",
    "\n",
    "!mkdir /content/drive/MyDrive/tip3p_sim\n",
    "!mkdir /content/drive/MyDrive/tip4p_sim\n",
    "!mkdir /content/drive/MyDrive/tip4p_phase_transition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3fe3bb0d-0f34-4bf1-9eb1-f7c28af6da5f",
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title **Check if you correctly allocated GPU nodes**\n",
    "#@markdown Again, only run this command if you are running this code in Google Colab!\n",
    "\n",
    "gpu_info = !nvidia-smi\n",
    "gpu_info = '\\n'.join(gpu_info)\n",
    "if gpu_info.find('failed') >= 0:\n",
    "  print('Select the Runtime > \"Change runtime type\" menu to enable a GPU accelerator, ')\n",
    "  print('and then re-execute this cell.')\n",
    "else:\n",
    "  print(gpu_info)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b5d3dab-2386-4017-857a-59adbbb0753a",
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title **Install Conda Colab**\n",
    "#@markdown It will restart the kernel (session), don't worry.\n",
    "!pip install -q condacolab\n",
    "import condacolab\n",
    "condacolab.install()\n",
    "!rm -rf /usr/local/conda-meta/pinned"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22704e0a-d386-40b0-9196-c327b7986a9b",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#@title **Install dependencies**\n",
    "#@markdown It will take a few minutes, please, drink a coffee and wait.\n",
    "# install dependencies\n",
    "#%%capture\n",
    "!pip -q install py3Dmol\n",
    "!pip install git+https://github.com/pablo-arantes/biopandas\n",
    "!conda install mamba -c conda-forge -y\n",
    "!mamba install -c conda-forge gcc=12.1.0 -y\n",
    "!mamba install openmm -c conda-forge -y\n",
    "!pip install --upgrade MDAnalysis\n",
    "!pip install seaborn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8a823183-bb88-44a3-97b2-8b163675e26d",
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title **Load dependencies**\n",
    "import sys\n",
    "import openmm as mm\n",
    "from openmm import *\n",
    "from openmm.app import *\n",
    "from openmm.unit import *\n",
    "import os\n",
    "import urllib.request  \n",
    "import numpy as np\n",
    "import MDAnalysis as mda\n",
    "from MDAnalysis.analysis.dielectric import DielectricConstant\n",
    "from MDAnalysis.analysis.rdf import InterRDF\n",
    "import py3Dmol\n",
    "import platform\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import seaborn as sb\n",
    "from matplotlib import colors\n",
    "from IPython.display import set_matplotlib_formats\n",
    "\n",
    "#conversion factors to get to correct units\n",
    "mass_to_kg = 1.66054e-27\n",
    "angstrom_to_m = 1e-10\n",
    "ps_to_s = 1e-12\n",
    "avogadro = 6.022e23\n",
    "\n",
    "#base path\n",
    "path = \"/content/drive/MyDrive/\"\n",
    "\n",
    "#files\n",
    "tip3p_traj = path + \"tip3p_sim/tip3p-traj.dcd\"\n",
    "tip3p_log = path + \"tip3p_sim/tip3p_log.csv\"\n",
    "tip3p_pdb = path + \"tip3p_sim/tip3p_minimized.pdb\"\n",
    "\n",
    "tip4p_traj = path + \"tip4p_sim/tip4p-traj.dcd\"\n",
    "tip4p_log = path + \"tip4p_sim/tip4p-log.csv\"\n",
    "tip4p_pdb = path + \"tip4p_sim/tip4p_minimized.pdb\"\n",
    "\n",
    "tip4p_pt_log = path + \"tip4p_phase_transition/tip4p-pt-log.csv\"\n",
    "tip4p_pt_pdb = path + \"tip4p_phase_transition/tip4p_minimized.pdb\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65ffc124-0c4c-4a92-afc3-c79c00c2c218",
   "metadata": {},
   "source": [
    "## 1  Preparing a Molecular Dynamics Simulation of Water"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c642b7de-0bd9-4b3a-8936-23726622e7f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title **Cosntruct the System**\n",
    "#@markdown Create a box with randomly placed TIP3P water molecules with periodic boundary conditions\n",
    "\n",
    "forcefield = ForceField(\"amber14-all.xml\", \"amber14/tip3p.xml\")\n",
    "modeller = Modeller(Topology(), [])\n",
    "modeller.addSolvent(forcefield, boxSize=Vec3(3, 3, 3)*nanometers, model='tip3p', neutralize=True, negativeIon='Cl-', positiveIon='Na+')\n",
    "system = forcefield.createSystem(modeller.topology, nonbondedMethod=PME,\n",
    "        nonbondedCutoff=1*nanometer, constraints=HBonds)\n",
    "print(\"Number of TIP3P water molecules in box in (3 nm)^3 cubic box: \", len(modeller.getPositions())/3) #divide by number of atoms in molecule (3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "0bf8313a-e7b0-4a5c-9040-a4d98783fe15",
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title **Add termostat & barostat. Set time step. Run energy minimization.**\n",
    "#@markdown Here we define the temperature of the system (300 K), the pressure (1 bar), assign random velocities to particles/molecules, and define our time step (dt) to be 2 fs. Then, we run a gradient descent energy minimization on the system.\n",
    "\n",
    "system.addForce(MonteCarloBarostat(1*bar, 300*kelvin))\n",
    "integrator = LangevinIntegrator(300*kelvin, 1/picosecond, 0.002*picoseconds)\n",
    "simulation = Simulation(modeller.topology, system, integrator)\n",
    "simulation.context.setPositions(modeller.positions)\n",
    "simulation.minimizeEnergy(tolerance=0.1*kilojoule/(nanometer*mole), maxIterations=100000)\n",
    "\n",
    "positions = simulation.context.getState(getPositions=True).getPositions()\n",
    "PDBFile.writeFile(simulation.topology, positions, open(tip3p_pdb, 'w'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6f622fc-cbba-42ae-a43d-1be229a680d1",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#@title **Visualize the System**\n",
    "\n",
    "view = py3Dmol.view(width=500, height=500)\n",
    "view.addModel(open( tip3p_pdb ,'r').read(),'pdb', {'keepH':'true'})\n",
    "sticky={'stick': {'radius': 0.15}, 'sphere': {'scale': 0.5}}\n",
    "view.setStyle(sticky,viewer=(0,0))\n",
    "view.addSurface(py3Dmol.SAS, {'opacity': 0.3, 'color':'blue'})\n",
    "view.zoomTo()\n",
    "view.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a2cbb31-0316-4997-879c-28a85708d162",
   "metadata": {},
   "source": [
    "## 2  Running & Analyzing the Simulation of Water"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f95d04bd-8c49-44eb-b91e-4e1fbe2de608",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#@title Run a Production Molecular Dynamics Simulation\n",
    "#@markdown This simulation should last for ~ 2 hrs and produce a ~2.5 GB trajectory file tip3p_sim/tip3p-traj.dcd in your Google Drive. The trajectory will contain dynamics information of water molecules over the course of 30 ns.\n",
    "\n",
    "simulation.reporters = []\n",
    "#record positions every 200 steps\n",
    "simulation.reporters.append(DCDReporter(tip3p_traj, 200))\n",
    "simulation.reporters.append(StateDataReporter(tip3p_log, 500, step=True, time=True,\n",
    "                                              temperature=True, kineticEnergy=True, elapsedTime=True))\n",
    "simulation.reporters.append(StateDataReporter(sys.stdout, 1000, step=True, time=True, elapsedTime=True))\n",
    "\n",
    "#run the simulation for defined number of steps with timestep of 2 fs\n",
    "simulation.step(15000000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3afbebf2-256c-4798-89a5-a208d424c573",
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Plotting Instantaneous Temperature and the Running Average Temperature\n",
    "#@markdown \n",
    "\n",
    "tip3p_data = pd.read_csv(tip3p_log)\n",
    "\n",
    "#calculate rolling average of the temperature\n",
    "rolling_avg = []\n",
    "for i in range(len(tip3p_data[\"Temperature (K)\"])):\n",
    "    j = i\n",
    "    rolling_avg.append(0)\n",
    "    while j >= 0 and j >= i-19:\n",
    "        rolling_avg[i] += tip3p_data[\"Temperature (K)\"][j]\n",
    "        j -= 1\n",
    "    if i < 10:\n",
    "        rolling_avg[i] = rolling_avg[i]/(i+1)\n",
    "    else:\n",
    "        rolling_avg[i] = rolling_avg[i]/(20)\n",
    "\n",
    "tip3p_data['Rolling Avg Temperature (K)'] = rolling_avg\n",
    "tip3p_data.plot(x=\"Time (ps)\", y=[\"Temperature (K)\", \"Rolling Avg Temperature (K)\"], style='-')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "efc42bd7-0e3a-42fb-a210-947b9d26e3f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title System Temperature and the Equipartition Theorem\n",
    "#@markdown \n",
    "\n",
    "print(\"Average Temperature (K): \", tip3p_data[\"Temperature (K)\"].mean())\n",
    "print(\"Average Kinetic Energy (kJ/mole): \", tip3p_data[\"Kinetic Energy (kJ/mole)\"].mean())\n",
    "print(\"(<KE>/<T>)*(1/Avogadro's Number): \", (tip3p_data[\"Kinetic Energy (kJ/mole)\"].mean()/tip3p_data[\"Temperature (K)\"].mean())/avogadro)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9aa25ab8-ea92-4034-aef1-236f2b04a129",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#@title Radial Distribution Function\n",
    "#@markdown \n",
    "\n",
    "universe = mda.Universe(tip3p_pdb, tip3p_traj)\n",
    "oxygen = universe.select_atoms(\"resname HOH and name O\")\n",
    "\n",
    "rdf = InterRDF(oxygen, oxygen, nbins=150, exclusion_block=(1, 1))\n",
    "rdf.run()\n",
    "\n",
    "plt.plot(rdf.bins, rdf.rdf)\n",
    "plt.xlabel('Radius [angstrom]')\n",
    "plt.ylabel('Radial distribution (g(r))')\n",
    "\n",
    "#bins start at 0.1 and increment by 0.1. Want to integrate out to 3.3 A\n",
    "sum = 0\n",
    "integration_range = int((3.3-0.1)/0.1)\n",
    "for i in range(integration_range):\n",
    "    sum += rdf.rdf[i]*0.1\n",
    "\n",
    "print(\"Result of integrating over g(r) through the first peak (0 to 3.3 A): \", sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1990d00-5969-4968-a5e5-b91bacd6f140",
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Calculate the density and dielectric constant of TIP3P water\n",
    "#@markdown \n",
    "\n",
    "universe = mda.Universe(tip3p_pdb, tip3p_traj)\n",
    "water = universe.select_atoms(\"resname HOH\")\n",
    "\n",
    "#mass density of water - first calculate total mass of water in box\n",
    "water_mass = 0\n",
    "for i in range(len(water)):\n",
    "    water_mass += water[i].mass * mass_to_kg\n",
    "\n",
    "av_density = 0\n",
    "for p in range(5, len(universe.trajectory)):\n",
    "    universe.trajectory[p]\n",
    "\n",
    "    volume = (universe.trajectory[p].dimensions[0]*angstrom_to_m) * (universe.trajectory[p].dimensions[1]*angstrom_to_m) * (universe.trajectory[p].dimensions[2]*angstrom_to_m)\n",
    "    av_density += water_mass/volume\n",
    "\n",
    "av_density = av_density/len(universe.trajectory)\n",
    "print(\"The average density of TIP3P water is: \", av_density, \" [kg/m^3]\")\n",
    "\n",
    "\n",
    "#dielectric constant of water\n",
    "\n",
    "#need charges from OpenMM\n",
    "n_atoms = system.getNumParticles()\n",
    "charges = []\n",
    "nonbonded = [f for f in system.getForces() if isinstance(f, NonbondedForce)][0]\n",
    "for i in range(n_atoms):\n",
    "    charge, sigma, epsilon = nonbonded.getParticleParameters(i)\n",
    "    charges.append(charge._value)\n",
    "\n",
    "#add this to universe topology\n",
    "universe.add_TopologyAttr('charges', charges)\n",
    "\n",
    "#need to add bond information as well\n",
    "bonds = []\n",
    "for o in range(0, n_atoms, 3):\n",
    "    bonds.extend([(o, o+1), (o, o+2)])\n",
    "\n",
    "universe.add_TopologyAttr('bonds', bonds)\n",
    "\n",
    "#Finally calculate the dielectric constant\n",
    "diel = DielectricConstant(universe.atoms)\n",
    "diel.run()\n",
    "print(\"Dielectric constant of TIP3P water: \", diel.results.eps_mean)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2807237-3290-439f-95a7-606e7ba72efb",
   "metadata": {},
   "source": [
    "### 3  Simulating a Different Representation of Water: TIP4P/2005"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c14c0e16-a7f7-4572-8f76-e9d02a31be36",
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Simulate TIP4P/2005 water model\n",
    "#@markdown This simulation should last for ~ 2 hrs and produce a ~4 GB trajectory file tip4p_sim/tip4p-traj.dcd in your Google Drive. The trajectory will contain dynamics information of water molecules over the course of 30 ns.\n",
    "\n",
    "#system setup\n",
    "forcefield = ForceField(\"charmm36.xml\", \"charmm36/tip4p2005.xml\")\n",
    "modeller = Modeller(Topology(), [])\n",
    "modeller.addSolvent(forcefield, boxSize=Vec3(3, 3, 3)*nanometers, model='tip4pew', neutralize=True, negativeIon='Cl-', positiveIon='Na+')\n",
    "modeller.addExtraParticles(forcefield)\n",
    "system = forcefield.createSystem(modeller.topology, nonbondedMethod=PME,\n",
    "        nonbondedCutoff=1*nanometer, constraints=HBonds)\n",
    "print(\"Number of TIP4P/2005 water molecules in box in (3 nm)^3 cubic box: \", len(modeller.getPositions())/4) #divide by number of atoms in molecule (4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a02b352d-60f8-491f-a375-3fcdbf056c10",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#@title Define Temperature, Pressure. Minimize the System. Run the Simulation.\n",
    "\n",
    "system.addForce(MonteCarloBarostat(1*bar, 300*kelvin))\n",
    "integrator = LangevinIntegrator(300*kelvin, 1/picosecond, 0.002*picoseconds)\n",
    "simulation = Simulation(modeller.topology, system, integrator)\n",
    "simulation.context.setPositions(modeller.positions)\n",
    "simulation.minimizeEnergy(tolerance=0.1*kilojoule/(nanometer*mole), maxIterations=100000)\n",
    "\n",
    "positions = simulation.context.getState(getPositions=True).getPositions()\n",
    "PDBFile.writeFile(simulation.topology, positions, open(tip4p_pdb, 'w'))\n",
    "\n",
    "#running simulation\n",
    "simulation.reporters = []\n",
    "simulation.reporters.append(DCDReporter(tip4p_traj, 200))\n",
    "simulation.reporters.append(StateDataReporter(tip4p_log, 500, step=True, time=True,\n",
    "                                              temperature=True, kineticEnergy=True, elapsedTime=True))\n",
    "simulation.reporters.append(StateDataReporter(sys.stdout, 1000, step=True, time=True, elapsedTime=True))\n",
    "\n",
    "simulation.step(15000000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa059f0a-46d0-42da-8be9-d6c56e1e0692",
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Calculate the density and dielectric constant of TIP4P/2005 to compare with TIP3P\n",
    "\n",
    "#begin analysis\n",
    "universe = mda.Universe(tip4p_pdb, tip4p_traj)\n",
    "water = universe.select_atoms(\"resname HOH\")\n",
    "\n",
    "#mass density of water - first calculate total mass of water in box\n",
    "water_mass = 0\n",
    "for i in range(len(water)):\n",
    "    water_mass += water[i].mass * mass_to_kg\n",
    "\n",
    "av_density = 0\n",
    "for p in range(5, len(universe.trajectory)):\n",
    "    universe.trajectory[p]\n",
    "\n",
    "    volume = (universe.trajectory[p].dimensions[0]*angstrom_to_m) * (universe.trajectory[p].dimensions[1]*angstrom_to_m) * (universe.trajectory[p].dimensions[2]*angstrom_to_m)\n",
    "    av_density += water_mass/volume\n",
    "\n",
    "av_density = av_density/len(universe.trajectory)\n",
    "print(\"The average density of TIP4P/2005 water is: \", av_density, \" [kg/m^3]\")\n",
    "\n",
    "\n",
    "#dielectric constant of water\n",
    "\n",
    "#need charges from OpenMM\n",
    "n_atoms = system.getNumParticles()\n",
    "charges = []\n",
    "nonbonded = [f for f in system.getForces() if isinstance(f, NonbondedForce)][0]\n",
    "for i in range(n_atoms):\n",
    "    charge, sigma, epsilon = nonbonded.getParticleParameters(i)\n",
    "    charges.append(charge._value)\n",
    "\n",
    "#add this to universe topology\n",
    "universe.add_TopologyAttr('charges', charges)\n",
    "\n",
    "#need to add bond information as well\n",
    "bonds = []\n",
    "for o in range(0, n_atoms, 4):\n",
    "    bonds.extend([(o, o+1), (o, o+2), (o, o+3)]) #extra term for the virtual particle\n",
    "\n",
    "universe.add_TopologyAttr('bonds', bonds)\n",
    "\n",
    "#Finally calculate the dielectric constant\n",
    "diel = DielectricConstant(universe.atoms)\n",
    "diel.run()\n",
    "print(\"Dielectric constant of TIP4P/2005 water: \", diel.results.eps_mean)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f81beb3-41f6-4631-8db4-75bd0eb38125",
   "metadata": {},
   "source": [
    "## 4  Simulating a Phase Transition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d9a1670-5aa3-4e52-8455-e7f6a32fa050",
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Simulate freezing of water with TIP4P/2005 water model\n",
    "#@markdown This simulation should last for ~ 4 hrs but only a log file will be produced in your Google Drive at tip4p_phase_transition/. It will contain information for 10 ns simulations for each temperature in range 305-260 K in 5 K intervals.\n",
    "\n",
    "#system setup\n",
    "forcefield = ForceField(\"charmm36.xml\", \"charmm36/tip4p2005.xml\")\n",
    "modeller = Modeller(Topology(), [])\n",
    "modeller.addSolvent(forcefield, boxSize=Vec3(3, 3, 3)*nanometers, model='tip4pew', neutralize=True, negativeIon='Cl-', positiveIon='Na+')\n",
    "modeller.addExtraParticles(forcefield)\n",
    "system = forcefield.createSystem(modeller.topology, nonbondedMethod=PME,\n",
    "        nonbondedCutoff=1*nanometer, constraints=HBonds)\n",
    "print(\"Number of TIP4P/2005 water molecules in box in (3 nm)^3 cubic box: \", len(modeller.getPositions())/4) #divide by number of atoms in molecule (4)\n",
    "\n",
    "#simulation details and energy minimization\n",
    "system.addForce(MonteCarloBarostat(1*bar, 305*kelvin))\n",
    "integrator = LangevinIntegrator(305*kelvin, 1/picosecond, 0.002*picoseconds)\n",
    "simulation = Simulation(modeller.topology, system, integrator)\n",
    "simulation.context.setPositions(modeller.positions)\n",
    "simulation.minimizeEnergy(tolerance=0.1*kilojoule/(nanometer*mole), maxIterations=100000)\n",
    "\n",
    "positions = simulation.context.getState(getPositions=True).getPositions()\n",
    "PDBFile.writeFile(simulation.topology, positions, open(tip4p_pt_pdb, 'w'))\n",
    "\n",
    "#running simulation\n",
    "simulation.reporters = []\n",
    "simulation.reporters.append(StateDataReporter(tip4p_pt_log, 200, step=True, time=True,\n",
    "                                              temperature=True, kineticEnergy=True, volume=True, density=True, elapsedTime=True))\n",
    "simulation.reporters.append(StateDataReporter(sys.stdout, 1000, step=True, time=True, elapsedTime=True))\n",
    "\n",
    "#10 ns simulations for each temperature in range 305-260 K in 5 K intervals\n",
    "#from here: https://openmm.github.io/openmm-cookbook/dev/notebooks/cookbook/Changing%20Temperature%20and%20Pressure.html\n",
    "for i in range(10):\n",
    "    temperature = (305-5*i)*kelvin\n",
    "    integrator.setTemperature(temperature)\n",
    "    simulation.context.setParameter(MonteCarloBarostat.Temperature(), temperature)\n",
    "    simulation.step(5000000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5856abb-7b23-4a63-a0d2-5f26682224f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title Calculate average mass density and box volume as functions of temperature\n",
    "\n",
    "tip4p_pt_data = pd.read_csv(tip4p_pt_log)\n",
    "num_data_points = 5000000/200\n",
    "tip4p_avgs = tip4p_pt_data.groupby(np.arange(len(tip4p_pt_data))//num_data_points).mean()\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.plot(tip4p_avgs[\"Temperature (K)\"], tip4p_avgs[\"Box Volume (nm^3)\"])\n",
    "plt.xlabel('Temperature [K]')\n",
    "plt.ylabel('Volume [nm^3]')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(tip4p_avgs[\"Temperature (K)\"], tip4p_avgs[\"Density (g/mL)\"])\n",
    "plt.xlabel('Temperature [K]')\n",
    "plt.ylabel('Density [g/mL]')\n",
    "\n",
    "plt.tight_layout()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}