{ "cells": [ { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" }, "tags": [] }, "source": [ "# Protein Folding with Intermediates" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" }, "tags": [] }, "source": [ "## Deterministic equations" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" }, "tags": [] }, "source": [ "A general set of chemical reactions can be described by the stoichiometry matrices $R$ and $P$ as:\n", "\\begin{equation}\n", "\\sum_i R_{\\mu i} S_i \\xrightarrow{k_u} \\sum_j P_{\\mu j} s_j\n", "\\end{equation}\n", "The general rate equations are:\n", "\\begin{equation}\n", "\\frac{dN_i}{dt} = \\sum_\\mu v_\\mu Q_{\\mu i}\n", "\\end{equation}\n", "where $Q \\equiv P - R$ is the net stoichiometry matrix and $v_\\mu$ is the reaction rate that we have calculated for stochastic simulations:\n", "\\begin{equation}\n", "v_\\mu = k_\\mu \\prod_i N_i^{R_{\\mu i}}\n", "\\end{equation}" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" }, "tags": [] }, "source": [ "Here is a general purpose class for solving rate equations." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "tags": [] }, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import scipy.integrate as intgr" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "slideshow": { "slide_type": "subslide" }, "tags": [] }, "outputs": [], "source": [ "class RateEquations:\n", " \"\"\"\n", " solve rate equations numerically, assuming mass action kinetics.\n", " \"\"\"\n", " \n", " def __init__(self, stoich, rates, init, record=True):\n", " \"\"\"\n", " initialize solver by assigning stoichiometry matrices, rate constants, and initial values.\n", " inputs:\n", " stoich: 2-tuple, stoichiometry matrices of reactants and products, (R_ui, P_ui), u = 1 ~ m, i = 1 ~ n\n", " rates: list, rate parameters, K_u, u = 1 ~ M\n", " init: list, initial numbers of every species, N_i(0), i = 1 ~ n\n", " record: boolean, whether to record numbers of species at time points\n", " \"\"\"\n", " self.reactants = np.asarray(stoich[0]) # stoichiometry matrices of reactants\n", " self.products = np.asarray(stoich[1]) # stoichiometry matrices of products\n", " self.rates = np.asarray(rates, dtype=float) # reaction rates\n", " self.numbers = np.asarray(init, dtype=float) # current numbers of each species, treat as real numbers\n", "\n", " self.num_reac = self.reactants.shape[0] # number of reactions\n", " self.num_spec = self.reactants.shape[1] # number of species\n", "\n", " self.time = 0. # time since beginning of simulation\n", " self.record = record # whether to record time series\n", "\n", " if self.record:\n", " self.time_hist = [0.] # list of time points\n", " self.numbers_hist = [self.numbers.copy()] # list of species numbers at time points\n", " \n", " \n", " def run(self, tmax, dt):\n", " \"\"\"\n", " solve rate equations until time `tmax` since the beginning.\n", " inputs:\n", " tmax: float, time since the beginning of the simulation.\n", " dt: float, time step by which solution is calculated\n", " \"\"\"\n", " T = tmax - self.time # time remaining to be solved\n", " new_times = np.arange(0, T+dt, dt) # new time points at every step dt\n", " x0 = self.numbers # current species numbers as initial values to the solver\n", " sol = intgr.odeint(self.mass_action, x0, new_times) # solve equations using integrator\n", " if self.record:\n", " self.time_hist.extend(self.time + new_times[1:]) # save time points\n", " self.numbers_hist.extend(sol[1:]) # save species numbers at given time points\n", " self.time += new_times[-1] # update time to latest\n", " self.numbers = sol[-1] # update species numbers to latest\n", " \n", " \n", " def mass_action(self, x, t):\n", " \"\"\"\n", " calculate time derivative of species numbers using mass action kinetics.\n", " inputs:\n", " x: 1-d array, current numbers of every species, treat as real numbers.\n", " t: float, current time.\n", " outputs:\n", " dxdt: 1-d array, time derivatives of species numbers.\n", " \"\"\"\n", " r_u = self.rates * np.prod(np.power(x, self.reactants), axis=1) # rates of every reaction\n", " Q_ui = self.products - self.reactants # net stoichiometry matrix\n", " dn_i = np.dot(r_u, Q_ui) # time derivatives of species numbers\n", " return dn_i\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" }, "tags": [] }, "source": [ "## Folding-unfolding model" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" }, "tags": [] }, "source": [ "Let us first test this `RateEquations` class on the simple folding-unfolding model we solved last time:\n", "\\begin{align*}\n", "U \\xrightarrow{k_f} F \\\\\n", "F \\xrightarrow{k_u} U\n", "\\end{align*}" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" }, "tags": [] }, "source": [ "Now we can define a derived class for our problem by specifying the stoichiometry matrices, like what we did for stochastic simulations." ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "slideshow": { "slide_type": "fragment" }, "tags": [] }, "outputs": [], "source": [ "class FoldingUnfolding2(RateEquations):\n", " \"\"\"\n", " define a derived class to model the folding and unfolding of proteins.\n", " \"\"\"\n", " \n", " def __init__(self, rates, init, record=True): # decorate base method\n", " \"\"\"\n", " modify the initialization to specify the stoichiometry matrices.\n", " the chemical species are U and F in that order; the reactions are U -> F and F -> U.\n", " \"\"\"\n", " reactants = [[1, 0],\n", " [0, 1]]\n", " products = [[0, 1],\n", " [1, 0]]\n", " RateEquations.__init__(self, (reactants, products), rates, init, record=record)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "slideshow": { "slide_type": "subslide" }, "tags": [] }, "outputs": [], "source": [ "kf = 9. # folding rate\n", "ku = 1. # unfolding rate\n", "\n", "NU0 = 100 # initial number of unfolded proteins\n", "NF0 = 0 # initial number of folded proteins\n", "N_tot = NU0 + NF0 # total number of proteins\n", "\n", "K = kf / ku # equilibrium constant\n", "NUeq = 1/(1+K) * N_tot # equilibrium number of unfolded proteins\n", "NFeq = K/(1+K) * N_tot # equilibrium number of folded proteins" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "slideshow": { "slide_type": "fragment" }, "tags": [] }, "outputs": [], "source": [ "T = 1.0\n", "dt = 0.01\n", "\n", "fu2 = FoldingUnfolding2([kf, ku], [NU0, NF0])\n", "fu2.run(T, dt)\n", "sol = np.array(fu2.numbers_hist)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "slideshow": { "slide_type": "subslide" }, "tags": [] }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots(1,2, figsize=(12,4))\n", "ax[0].axhline(NUeq, color='k', linewidth=2, label='equilibrium') # expected number at equilibrium\n", "ax[1].axhline(NFeq, color='k', linewidth=2, label='equilibrium') # expected number at equilibrium\n", "ax[0].plot(fu2.time_hist, sol[:,0], 'k--', label='solution') # solution to the rate equations\n", "ax[1].plot(fu2.time_hist, sol[:,1], 'k--', label='solution') # solution to the rate equations\n", "ax[0].set_ylim(-2, 102)\n", "ax[0].set_xlabel('time')\n", "ax[0].set_ylabel('#unfolded')\n", "ax[0].legend(loc='upper right')\n", "ax[1].set_ylim(-2, 102)\n", "ax[1].set_xlabel('time')\n", "ax[1].set_ylabel('#folded')\n", "ax[1].legend(loc='lower right')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" }, "tags": [] }, "source": [ "## Folding-unfolding with an intermediate" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" }, "tags": [] }, "source": [ "Let us consider a slightly more complicated model of protein folding, where the transition from the unfolded state to the folded state has to go through an intermediate state that is metastable. Denote the intermediate state by $M$, then there will be four reactions:\n", "\\begin{align}\n", "U \\xrightarrow{k_m} M \\\\\n", "M \\xrightarrow{k_f} F \\\\\n", "F \\xrightarrow{k_d} M \\\\\n", "M \\xrightarrow{k_u} U\n", "\\end{align}" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" }, "tags": [] }, "source": [ "### **Exercise**: solve the extended model using rate equations." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" }, "tags": [] }, "outputs": [], "source": [ "km = 9. # folding rate of intermediate\n", "ku = 1. # unfolding rate of intermediate\n", "kf = 3. # folding rate of final state\n", "kd = 0.3 # unfolding rate of final state\n", "\n", "NU0 = 100 # initial number of unfolded proteins\n", "NF0 = 0 # initial number of folded proteins\n", "NM0 = 0 # initial number of intermediate state\n", "N_tot = NU0 + NF0 + NM0 # total number of proteins" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "subslide" }, "tags": [] }, "outputs": [], "source": [ "class FoldingUnfoldingWithIntermediate(RateEquations):\n", " \"\"\"\n", " define a derived class to model the folding and unfolding of proteins.\n", " \"\"\"\n", " \n", " def __init__(self, rates, init, record=True): # decorate base method\n", " \"\"\"\n", " modify the initialization to specify the stoichiometry matrices.\n", " the chemical species are U and F in that order; the reactions are U -> F and F -> U.\n", " \"\"\"\n", " reactants = ...\n", " products = ...\n", " RateEquations.__init__(self, (reactants, products), rates, init, record=record)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" }, "tags": [] }, "outputs": [], "source": [ "T = 2.0\n", "dt = 0.01\n", "\n", "fu2 = ..." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "subslide" }, "tags": [] }, "outputs": [], "source": [ "time_hist = np.array(fu2.time_hist)\n", "num_hist = np.array(fu2.numbers_hist)\n", "\n", "fig, ax = plt.subplots(1,3, figsize=(18,4))\n", "for i in range(3):\n", " ax[i].plot(time_hist, num_hist[:,i], 'k--', label='solution') # solution to the rate equations\n", " ax[i].set_ylim(-2, 102)\n", " ax[i].set_xlabel('time')\n", " ax[i].legend()\n", "ax[0].set_ylabel('#unfolded')\n", "ax[1].set_ylabel('#intermediate')\n", "ax[2].set_ylabel('#folded')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" }, "tags": [] }, "source": [ "### **Challenge**: Calculate the equilibrium numbers in terms of the rate constants and compare to numerical results" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": { "jp-MarkdownHeadingCollapsed": true, "tags": [] }, "source": [ "### **Solution**:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "slideshow": { "slide_type": "fragment" }, "tags": [] }, "outputs": [], "source": [ "class FoldingUnfoldingWithIntermediate(RateEquations):\n", " \"\"\"\n", " define a derived class to model the folding and unfolding of proteins.\n", " \"\"\"\n", " \n", " def __init__(self, rates, init, record=True): # decorate base method\n", " \"\"\"\n", " modify the initialization to specify the stoichiometry matrices.\n", " the chemical species are U and F in that order; the reactions are U -> F and F -> U.\n", " \"\"\"\n", " reactants = [[1, 0, 0],\n", " [0, 1, 0],\n", " [0, 0, 1],\n", " [0, 1, 0]]\n", " products = [[0, 1, 0],\n", " [0, 0, 1],\n", " [0, 1, 0], \n", " [1, 0, 0]]\n", " RateEquations.__init__(self, (reactants, products), rates, init, record=record)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "slideshow": { "slide_type": "fragment" }, "tags": [] }, "outputs": [], "source": [ "T = 2.0 # total amount of time to solve\n", "dt = 0.01 # time step by which the solutions are recorded\n", "\n", "fu2 = FoldingUnfoldingWithIntermediate([km, kf, kd, ku], [NU0, NM0, NF0])\n", "fu2.run(T, dt)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "K1 = kf / kd\n", "K2 = ku / km\n", "NUeq = K2 / (1 + K1 + K2) * N_tot # equilibrium number of unfolded proteins\n", "NMeq = 1 / (1 + K1 + K2) * N_tot # equilibrium number of intermediates\n", "NFeq = K1 / (1 + K1 + K2) * N_tot # equilibrium number of folded proteins" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "slideshow": { "slide_type": "subslide" }, "tags": [] }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "time_hist = np.array(fu2.time_hist)\n", "num_hist = np.array(fu2.numbers_hist)\n", "\n", "fig, ax = plt.subplots(1,3, figsize=(18,4))\n", "ax[0].axhline(NUeq, color='k', linewidth=2, label='equilibrium') # expected number at equilibrium\n", "ax[1].axhline(NMeq, color='k', linewidth=2, label='equilibrium') # expected number at equilibrium\n", "ax[2].axhline(NFeq, color='k', linewidth=2, label='equilibrium') # expected number at equilibrium\n", "for i in range(3):\n", " ax[i].plot(time_hist, num_hist[:,i], 'k--', label='solution') # solution to the rate equations\n", " ax[i].set_ylim(-2, 102)\n", " ax[i].set_xlabel('time')\n", " ax[i].legend()\n", "ax[0].set_ylabel('#unfolded')\n", "ax[1].set_ylabel('#intermediate')\n", "ax[2].set_ylabel('#folded')\n", "plt.show()" ] } ], "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.8.10" } }, "nbformat": 4, "nbformat_minor": 4 }