{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "## Model a dual activator system with an AND gate\n", "\n", "There are now two factors X and Y. Both are activators and their effects are multiplied. This means the model's activation function is\n", "\n", "$\\beta \\frac{x^{H}}{K_{zx}^{H}+x^{H}} \\frac{y^{H}}{K_{zy}^{H}+y^{H}} = \\beta \\frac{(x/K_{zx})^{H}}{1+(x/K_{zx})^{H}} \\frac{(y/K_{zy})^{H}}{1+(y/K_{zy})^{H}}$\n", "\n", "where $\\beta$ is the maximal rate of transcription of Z, $H$ is the Hill coefficient (using the same value for both expressions, for the sake of simplicity), $K_{zx}$ is the activation threshold for X on Z, $K_{zy}$ is the activation threshold for Y on Z, and now $X$ and $Y$ are both parameters that will change over time.\n", "\n", "The full model is\n", "\n", "$\\frac{dZ}{dt} = \\beta \\frac{x^{H}}{K_{zx}^{H}+x^{H}} \\frac{y^{H}}{K_{zy}^{H}+y^{H}} - \\alpha Z$\n", "\n", "where $\\alpha$ is the degradation rate constant." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import scipy.integrate\n", "import matplotlib.pyplot as plt\n", "\n", "def dual_activator_AND( t, statevars, params):\n", " Z = statevars[0]\n", " beta = params[0]\n", " H = params[1]\n", " Kzx = params[2]\n", " Kzy = params[3]\n", " alpha = params[4]\n", " X = params[5]\n", " Y = params[6]\n", " \n", " dstatevarsdt = np.zeros( (1,) )\n", " dstatevarsdt[0] = beta * ((X**H)/(Kzx**H+X**H)) * ((Y**H)/(Kzy**H+Y**H)) - alpha*Z\n", " return dstatevarsdt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Simulate the model\n", "\n", "Use $\\beta=1$, $K_{zx}=0.5$, $H=5$, $K_{zy}=0.5$, and $\\alpha=1$. X should be 0 until t=0.5, and 1 thereafter. Y should be 0 until t=5, and 1 thereafter. \n", "\n", "Simulate from t=0 to t=20 with a time steps of 0.01." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "# Assign each parameter a name by value\n", "beta = 1;\n", "Kzy = 0.5;\n", "Kzx = 0.5;\n", "H = 5;\n", "alpha = 1;\n", "\n", "# Set up parameters so that X is off, and then X is on, and then both X and Y are on.\n", "time_x_on = 0.5\n", "time_y_on = 5\n", "\n", "params_off = (beta, H, Kzx, Kzy, alpha,0,0);\n", "params_Xon = (beta, H, Kzx, Kzy, alpha,1,0);\n", "params_XYon = (beta, H, Kzx, Kzy, alpha,1,1);\n", "\n", "# Make versions of the model X,Y off/on pattern\n", "mf_off = lambda t,y : dual_activator_AND(t,y, params_off)\n", "mf_Xon = lambda t,y : dual_activator_AND(t,y, params_Xon)\n", "mf_XYon = lambda t,y : dual_activator_AND(t,y, params_XYon)\n", "\n", "# Simulate first with X off, then turn X on, then turn both on.\n", "sol1 = scipy.integrate.solve_ivp( fun=mf_off, t_span=(0,time_x_on), y0=(0,), \n", " t_eval=np.arange(0,time_x_on,.01) )\n", "sol2 = scipy.integrate.solve_ivp( fun=mf_Xon, t_span=(time_x_on,time_y_on), y0=sol1.y[:,-1], \n", " t_eval=np.arange(time_x_on,time_y_on,.01) )\n", "sol3 = scipy.integrate.solve_ivp( fun=mf_XYon, t_span=(time_y_on,20), y0=sol2.y[:,-1], \n", " t_eval=np.arange(time_y_on,20,.01) )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Plot the simulation\n", "\n", "Plot X over time in an upper subplot, Y over time in a middle subplot, and Z over time in a lower subplot." ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "scrolled": true }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEZCAYAAADCJLEQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAgyUlEQVR4nO3dfZRcdZ3n8fcn3XkgMSEJCSEhYAODYFAeQi8CqxwEFyMqcRQdWM8aH3bQVY6657gOcziD6B73LD7O6jI6QTMCKsZnghMGojKDO2OQTkxCHpCEkEhCSDoE0oQASbq/+8e9zRRFVaexq+79VffndU6dvnXv71Z98utf32/uQ91SRGBmZpaaUWUHMDMzq8UFyszMkuQCZWZmSXKBMjOzJLlAmZlZklygzMwsSaUXKEmLJO2StLbsLGZmlg6V/TkoSRcA+4BbIuI1h2s/bdq06OjoaHouMzMrxooVK3ZHxPTq+e1lhKkUEfdK6hhs+46ODrq6upqYyMzMiiRpa635pReoFH3/vj9y+6rtZccwM0venFmT+MzbT2vKa5d+DmowJF0lqUtSV3d3d9Pf7/ZV21m/o6fp72NmZvW1xB5URCwEFgJ0dnYWctJszsxJLP7weUW8lZmZ1dASe1BmZjbylF6gJN0G/BY4RdI2SR8qO5OZmZWv9EN8EXFl2RnMzCw9pe9BmZmZ1eICZWZmSXKBMjOzJLlAmZlZklygzMwsSS5QZmaWJBcoMzNLkguUmZklyQXKzMyS5AJlZmZJcoEyM7MkuUCZmVmSXKDMzCxJLlBmZpYkFygzM0uSC5SZmSXJBcrMzJLkAmVmZklygTIzsyQNuUBJOn6AZW8Y6uubmdnI1Ig9qH+W9GlJbf0zJM2Q9F3gqw14fTMzG4EaUaDOBk4CVkm6SNIngN8BvwXOacDrm5nZCNQ+1BeIiCeBD+eF6ZfAY8C5EbFtqK9tZmYjVyPOQU2W9PfAB4B5wI+BOyVdNNTXNjOzkWvIe1DASuDvgI9FxCHgbklnAn8naWtEXNmA9zAzsxGmEQXqgurDeRGxCjhf0l824PXNzGwEGvIhvoHONUXETUN9fTMzG5n8QV0zM0uSC5SZmSXJBcrMzJLkAmVmZklygTIzsyS5QJmZWZJcoMzMLEkuUGZmliQXKDMzS5ILlJmZJckFyszMkuQCZWZmSXKBMjOzJLlAmZlZklygzMwsSS5QZmaWJBcoMzNLkguUmZklqfQCJWmepD9I2iTpmrLzmJlZGkotUJLagBuBtwBzgCslzSkzk5mZpaHsPahzgE0RsTkiDgA/AOaXnMnMzBLQXvL7Hws8WvF8G/C6Zr7hZ+9Yx/rHegZss35HD3NmTmpmDDMzO4yy96AGRdJVkrokdXV3dzf9/ebMnMT8M49t+vuYmVl9Ze9BbQeOq3g+O5/3IhGxEFgI0NnZGUN5w8+8/bShrG5mZgVRxJC290N7c6kdeAi4mKww3Q/854hYN8A63cDWIb71NGD3EF+jKK2S1Tkbr1WytkpOaJ2srZITGpP1lRExvXpmqXtQEXFI0tXAXUAbsGig4pSv85J/xMslqSsiOof6OkVolazO2XitkrVVckLrZG2VnNDcrGUf4iMilgJLy85hZmZpaYmLJMzMbOQZqQVqYdkBXoZWyeqcjdcqWVslJ7RO1lbJCU3MWupFEmZmZvWM1D0oMzNL3LAuUIe7Ea2ksZIW58vvk9RRQsbjJN0jab2kdZI+UaPNhZL2SlqVP64rOmdFli2SHshzdNVYLklfy/t0jaS5JWQ8paKvVknqkfTJqjal9amkRZJ2SVpbMW+qpGWSNuY/p9RZd0HeZqOkBSXk/KKkB/Pf7c8kTa6z7oDjpKCs10vaXvE7vrTOuoXdsLpOzsUVGbdIWlVn3cL6tN52qfBxGhHD8kF22frDwInAGGA1MKeqzUeBb+bTVwCLS8g5E5ibT08k+1xYdc4LgV+U3ad5li3AtAGWXwrcCQg4F7gvgXHwONnnLJLoU+ACYC6wtmLeF4Br8ulrgBtqrDcV2Jz/nJJPTyk45yVAez59Q62cgxknBWW9HvjUIMbHgNuJZuesWv5l4Lqy+7TedqnocTqc96AGcyPa+cDN+fSPgYslqcCMRMSOiFiZTz8NbCC7R2Grmg/cEpnlwGRJM0vMczHwcEQM9cPdDRMR9wJ7qmZXjsWbgXfUWPXNwLKI2BMRTwLLgHlF5oyIuyPiUP50OdndX0pXp08Ho9AbVg+UM9/2vAe4rVnvP1gDbJcKHafDuUDVuhFt9Yb/hTb5H91e4KhC0tWQH2I8C7ivxuLzJK2WdKekMu/XFMDdklZIuqrG8sH0e5GuoP4ffCp9CjAjInbk048DM2q0Sa1vP0i2t1zL4cZJUa7OD0cuqnM4KqU+fQOwMyI21lleSp9WbZcKHafDuUC1FEmvAH4CfDIiqm+3vpLsENUZwNeBnxccr9LrI2Iu2Xd4fUzSBSVmGZCkMcBlwI9qLE6pT18ksuMkSV9eK+la4BDwvTpNUhgn3wBOAs4EdpAdPkvZlQy891R4nw60XSpinA7nAjWYG9G+0EbZfQGPBJ4oJF0FSaPJBsH3IuKn1csjoici9uXTS4HRkqYVHLM/y/b85y7gZ2SHSCoN6gbABXkLsDIidlYvSKlPczv7D4XmP3fVaJNE30p6P/A24L35RuolBjFOmi4idkZEb0T0ATfVyZBKn7YD7wQW12tTdJ/W2S4VOk6Hc4G6HzhZ0gn5/6SvAJZUtVkC9F9hcjnw63p/cM2SH3f+NrAhIr5Sp80x/efGJJ1D9nsro5BOkDSxf5rshPnaqmZLgPcpcy6wt+KQQNHq/o80lT6tUDkWFwC312hzF3CJpCn54apL8nmFkTQP+DRwWUTsr9NmMOOk6arOff55nQyD2U4U4U3AgxGxrdbCovt0gO1SseO0iCtCynqQXVH2ENlVOtfm8z5H9scFMI7s8M8m4HfAiSVkfD3ZbvIaYFX+uBT4CPCRvM3VwDqyK4yWA+eX1J8n5hlW53n6+7Qyq4Ab8z5/AOgsKesEsoJzZMW8JPqUrGjuAA6SHZ//ENm5z18BG4FfAlPztp3AtyrW/WA+XjcBHygh5yay8wv9Y7X/KthZwNKBxkkJWW/Nx+Aasg3rzOqs+fOXbCeKzJnP/07/2KxoW1qfDrBdKnSc+k4SZmaWpOF8iM/MzFqYC5SZmSXJBcrMzJLkAmVmZklygTIzsyS5QJmZWZJcoMzMLEkuUGZmliQXKDMzS5ILlJmZJckFyszMkuQCZWZmSSq9QOXfdLlLUuG34zczs3SVfjfz/Fsh9wG3RMRrDtd+2rRp0dHR0fRcZmZWjBUrVuyOiOnV89vLCFMpIu7Nv/N+UDo6Oujq6mpiIjMzK5KkrbXml16grPV9/74/cvuqsr7V3czKNGfWJD7z9tOa8tqln4MaDElXSeqS1NXd3V12HKty+6rtrN/RU3YMMxtmWmIPKiIWAgsBOjs7/RXACZozcxKLP3xe2THMbBhpiT0oMzMbeUovUJJuA34LnCJpm6QPlZ3JzMzKV/ohvoi4suwMZmaWntL3oMzMzGpxgTIzsyS5QJmZWZJcoMzMLEkuUGZmliQXKDMzS5ILlJmZJckFyszMkuQCZWZmSXKBMjOzJLlAmZlZklygzMwsSS5QZmaWJBcoMzNLkguUmZklyQXKzMyS5AJlZmZJcoEyM7MkuUCZmVmShlygJC2V1NGALGZmZi9oxB7UPwB3S7pW0ugGvJ6ZmRntQ32BiPiRpDuBvwG6JN0K9FUs/8pQ38PMzEaeIReo3AHgGWAsMJGKAmVmZvanGHKBkjQP+AqwBJgbEfuHnMrMzEa8RuxBXQu8OyLWNeC1zMzMgMacg3pDI4KYmZlV8uegzMwsSS5QZmaWJBcoMzNLkguUmZklyQXKzMyS5AJlZmZJcoEyM7MkuUCZmVmSXKDMzCxJLlBmZpYkFygzM0uSC5SZmSXJBcrMzJLkAmVmZklygTIzsyS5QJmZWZJcoMzMLEkuUGZmlqTSC5SkeZL+IGmTpGvKzmNmZmkotUBJagNuBN4CzAGulDSnzExmZpaGsvegzgE2RcTmiDgA/ACYX3ImMzNLQHvJ738s8GjF823A65r5hp+9Yx3rH+tp5luMOOt39DBn5qSyY5jZMFP2HtSgSLpKUpekru7u7rLjWJU5Mycx/8xjy45hZsNM2XtQ24HjKp7Pzue9SEQsBBYCdHZ2xlDe8DNvP20oq5uZWUHK3oO6HzhZ0gmSxgBXAEtKzmRmZglQxJB2SIYeQLoU+FugDVgUEZ8/TPtuYOsQ33YasHuIr1GUVsnqnI3XKllbJSe0TtZWyQmNyfrKiJhePbP0AlUGSV0R0Vl2jsFolazO2XitkrVVckLrZG2VnNDcrGUf4jMzM6vJBcrMzJI0UgvUwrIDvAytktU5G69VsrZKTmidrK2SE5qYdUSegzIzs/SN1D0oMzNL3LAuUIe7U7qksZIW58vvk9RRQsbjJN0jab2kdZI+UaPNhZL2SlqVP64rOmdFli2SHshzdNVYLklfy/t0jaS5JWQ8paKvVknqkfTJqjal9amkRZJ2SVpbMW+qpGWSNuY/p9RZd0HeZqOkBSXk/KKkB/Pf7c8kTa6z7oDjpKCs10vaXvE7vrTOuoV9o0KdnIsrMm6RtKrOuoX1ab3tUuHjNCKG5YPsc1UPAycCY4DVwJyqNh8FvplPXwEsLiHnTGBuPj0ReKhGzguBX5Tdp3mWLcC0AZZfCtwJCDgXuC+BcfA42ecskuhT4AJgLrC2Yt4XgGvy6WuAG2qsNxXYnP+ckk9PKTjnJUB7Pn1DrZyDGScFZb0e+NQgxseA24lm56xa/mXgurL7tN52qehxOpz3oAZzp/T5wM359I+BiyWpwIxExI6IWJlPPw1sILuJbquaD9wSmeXAZEkzS8xzMfBwRAz1w90NExH3AnuqZleOxZuBd9RY9c3AsojYExFPAsuAeUXmjIi7I+JQ/nQ52e3JSlenTwej0G9UGChnvu15D3Bbs95/sAbYLhU6Todzgap1p/TqDf8LbfI/ur3AUYWkqyE/xHgWcF+NxedJWi3pTkll3lAwgLslrZB0VY3lg+n3Il1B/T/4VPoUYEZE7MinHwdm1GiTWt9+kGxvuZbDjZOiXJ0fjlxU53BUSn36BmBnRGyss7yUPq3aLhU6TodzgWopkl4B/AT4ZERUfx/ISrJDVGcAXwd+XnC8Sq+PiLlkXzL5MUkXlJhlQMru73gZ8KMai1Pq0xeJ7DhJ0pfXSroWOAR8r06TFMbJN4CTgDOBHWSHz1J2JQPvPRXepwNtl4oYp8O5QA3mTukvtJHUDhwJPFFIugqSRpMNgu9FxE+rl0dET0Tsy6eXAqMlTSs4Zn+W7fnPXcDPyA6RVBrUHeoL8hZgZUTsrF6QUp/mdvYfCs1/7qrRJom+lfR+4G3Ae/ON1EsMYpw0XUTsjIjeiOgDbqqTIZU+bQfeCSyu16boPq2zXSp0nA7nAjWYO6UvAfqvMLkc+HW9P7hmyY87fxvYEBFfqdPmmP5zY5LOIfu9lVFIJ0ia2D9NdsJ8bVWzJcD7lDkX2FtxSKBodf9HmkqfVqgciwuA22u0uQu4RNKU/HDVJfm8wkiaB3wauCwi9tdpM5hx0nRV5z7/vE6GVL5R4U3AgxGxrdbCovt0gO1SseO0iCtCynqQXVH2ENlVOtfm8z5H9scFMI7s8M8m4HfAiSVkfD3ZbvIaYFX+uBT4CPCRvM3VwDqyK4yWA+eX1J8n5hlW53n6+7Qyq4Ab8z5/AOgsKesEsoJzZMW8JPqUrGjuAA6SHZ//ENm5z18BG4FfAlPztp3AtyrW/WA+XjcBHygh5yay8wv9Y7X/KthZwNKBxkkJWW/Nx+Aasg3rzOqs+fOXbCeKzJnP/07/2KxoW1qfDrBdKnSc+k4SZmaWpOF8iM/MzFqYC5SZmSXJBcrMzJLkAmVmZklygTIzsyS5QJmZWZJcoMzMLEkuUGZmliQXKDMzS5ILlJmZJckFyszMkuQCZWZmSXKBMjOzJLWXHeDlmjZtWnR0dJQdw8zMGmTFihW7I2J69fyWK1AdHR10dXWVHcOs5UQEfUH/9/W88F3dERD5s+pv36m1LKj9Gv0zXk77yFZ40bKUpPZtRJFgLx15xGjGjxlaKZG0tdb8litQZil7/lAve/cf5KlnD/LM84d49kAvzxzoZf+BbHr/gV6ePZg9f+5gHwd7s8eBQ/HC9MHePg70BgcPVT3v7aOvL+iLoDeCvj7ozZ/3ReTT0NeXLe/tCyJ4YdqsGb707jO4/OzZTXltFyizAUQET+4/yM6e59jZ8xy7ep7Ppp9+jif2HeCp/Qd5cv8B9j57kKf2H+TZg72Det22UWJc+yjGtI9idFv2yKbF6LZRtLeNYkybGNM+iglj2/M2om1U9hil7NE2imx6lGhTtkzihelRo8So/PmofD3IvvYYIH+K+icq5+WtpBrtERWrvOg19KJ2/76seh4121e9aAKq/51lSywOc4+f3LTXdoEyA5490MuDj/fw0M6n2fLEfrY+8QyP7M5+7j/w0qIzefxopr1iLFPGj2b2lPG85tjRTD5iNJPHj+bI8WOYfMRoXjG2nSPGtDE+fxwxpp0JY9o4YkwbY9pGvagomNlLuUDZiHOwt4+12/dy/5Y9PLC9h/WP7eWR3c/QfxRsdJs4bsp4XnnUeF53wlSOmzqeYyaNY8akscyYNI7pE8cybnRbuf8IsxHABcqGvYhg3WM93PPgLpY/8gQrtz71wqG4YycfwZxZk3jb6bM4bdYkTj1mErMmj6O9zZ/AMCubC5QNS719wW8ffoKla3fw6w27eLznOSR49TGT+Iv/cBznnDCVzo4pHD1xXNlRzawOFygbVjbtepofdW3j56u2s7PneSaMaeOCV03nolOP5o2nHs20V4wtO6KZDZILlLW8vr7g3o3dfPv/PcJvNu6mfZS48JTpXPe22Vz86qN9vsisRblAWcuKCJat38mX736IP+x8mqMnjuVTl7yKK8453ntKZsOAC5S1pN89sof/tXQDqx59ihOmTeDL7z6Dt58xizHtvrjBbLhwgbKWsueZA3z+Hzfwk5XbmHXkOG5412t519zZvurObBhygbKWccfqx/ib29fyzPOH+NgbT+LqN57MEWN8fslsuHKBsuTte/4Q1y9Zx49XbOOs4yfzhXedzskzJpYdy8yazAXKkrZp1z7+8pYutj7xDB+/+GQ+ftGf+XCe2QjhAmXJ+peHurn6+ysZ2z6K2/7yXF534lFlRzKzArlAWZJ+eP+jXPPTNbxqxkS+taCT2VPGlx3JzArmAmXJ+c6/PsL1d6zngldN5xvvncuEsR6mZiOR//ItKTfdu5nPL93Am0+bwdeuPIux7b5Kz2ykcoGyZCy+/498fukG3nr6TP72L85ktC+GMBvRvAWwJNy17nH++qcPcMGrpvPV97g4mZkLlCVg7fa9fPy23/Pa2ZP5xnvn+nZFZga4QFnJ9jxzgA/fuoKpE8bw7QWdviDCzF7Q1AIlaZ6kP0jaJOmaGsvfL6lb0qr88V+bmcfScqi3j6u/v5Lufc/z9//lbN+B3MxepGn/XZXUBtwI/CdgG3C/pCURsb6q6eKIuLpZOSxd3/jnh/m3h5/gi5efzumzJ5cdx8wS08w9qHOATRGxOSIOAD8A5jfx/ayFrH70Kf7PrzZy2RmzeHfncWXHMbMEDVigJL15gGXvPsxrHws8WvF8Wz6v2rskrZH0Y0neUo0A+w8c4r8vXsXRE8fyP+e/puw4Zpaow+1BLZV0j6RaheWvG/D+dwAdEXE6sAy4uVYjSVdJ6pLU1d3d3YC3tTJ9ddlDbN79DF96zxkcOX502XHMLFGHK1BrgO8DyyVdXrVMh1l3O1C5RzQ7n/eCiHgiIp7Pn34LOLvWC0XEwojojIjO6dOnH+ZtLWXrH+th0b9u4cpzjuf8k6aVHcfMEna4AhURcRNwMfBXkv5BUv9dO+Mw694PnCzpBEljgCuAJZUNJM2seHoZsGHw0a3V9PUF1/78ASYfMZq/mndK2XHMLHGDukgiIh4CzgN2Ar+X9LpBrHMIuBq4i6zw/DAi1kn6nKTL8mYfl7RO0mrg48D7/4R/g7WIxV2P8vs/PsW1b301k8ePKTuOmSVOEfV3hCT9PiLOqpp3IbAImB4RhX+taWdnZ3R1dRX9tjZE+54/xIVfvIcTpk3ghx8+D+lwR4jNbKSQtCIiOqvnH+5zUJ+tnhER/yzpbODDjQpnw99N925m974D3PS+ThcnMxuUAQtURPy8zvwngf/djEA2/Ox6+jlu+s1mLn3tMZx1/JSy45hZi/C9+Kzp/u+vN3HgUB//482nlh3FzFqIC5Q11a6e5/jB/Y9y+dmzOWHahLLjmFkLcYGyprrpN5s51NvHf7vwpLKjmFmLcYGyptnzzAG+u/yPzD/zWF55lPeezOzlcYGypvnOvz7Cc4d6+aj3nszsT+ACZU3x3MFebl2+lTe9egYnzyj843JmNgy4QFlTLFn9GE/uP8gH/mNH2VHMrEW5QFnDRQQ3/9sWTpkxkfNOPKrsOGbWolygrOG6tj7Jusd6WHB+h+8aYWZ/Mhcoa7hbfruVSePaecdZs8qOYmYtzAXKGuqp/Qe4a+3jvHPubMaPOdytHs3M6nOBsoZasvoxDvT28e7O2WVHMbMW5wJlDfXDrkeZM3MSp806suwoZtbiXKCsYTbs6GHt9h7vPZlZQ7hAWcP8qGsbo9vE/DOPLTuKmQ0DLlDWEL19wR1rHuOiU49m6gR/nbuZDZ0LlDXE/Vv20P3087ztdF9abmaN0dQCJWmepD9I2iTpmhrLx0panC+/T1JHM/NY8/zjmh2MGz2Ki049uuwoZjZMNK1ASWoDbgTeAswBrpQ0p6rZh4AnI+LPgK8CNzQrjzXPod4+7ly7g4tPncGEsf7sk5k1RjP3oM4BNkXE5og4APwAmF/VZj5wcz79Y+Bi+d44Led3j+xh974DvPX0mWVHMbNhpJn/3T0WeLTi+TbgdfXaRMQhSXuBo4DdzQr12TvWsf6xngHbPP3cQSaOG92sCMPOI7ufoX2UeOMpPrxnZo3TEhdJSLpKUpekru7u7rLjWJWDvX0cP3U8R4xpKzuKmQ0jzdyD2g4cV/F8dj6vVpttktqBI4Enql8oIhYCCwE6OztjKKE+8/bThrK61dHbN6Rfi5nZSzRzD+p+4GRJJ0gaA1wBLKlqswRYkE9fDvw6Iryla0Fto3zq0MwaS82sB5IuBf4WaAMWRcTnJX0O6IqIJZLGAbcCZwF7gCsiYvNhXrMb2DrEaNNo4nmuBmuVrM7ZeK2StVVyQutkbZWc0Jisr4yI6dUzm1qgUiWpKyI6y84xGK2S1Tkbr1WytkpOaJ2srZITmpu1JS6SMDOzkccFyszMkjRSC9TCsgO8DK2S1Tkbr1WytkpOaJ2srZITmph1RJ6DMjOz9I3UPSgzM0vcsC5QrXA3dUnHSbpH0npJ6yR9okabCyXtlbQqf1xXdM6KLFskPZDn6KqxXJK+lvfpGklzS8h4SkVfrZLUI+mTVW1K61NJiyTtkrS2Yt5UScskbcx/Tqmz7oK8zUZJC2q1aXLOL0p6MP/d/kzS5DrrDjhOCsp6vaTtFb/jS+usO+B2ooCciysybpG0qs66hfVpve1S4eM0Ioblg+yzVw8DJwJjgNXAnKo2HwW+mU9fASwuIedMYG4+PRF4qEbOC4FflN2neZYtwLQBll8K3AkIOBe4L4Fx8DjZ5yyS6FPgAmAusLZi3heAa/Lpa4Abaqw3Fdic/5yST08pOOclQHs+fUOtnIMZJwVlvR741CDGx4DbiWbnrFr+ZeC6svu03nap6HE6nPegWuJu6hGxIyJW5tNPAxvIbqLbquYDt0RmOTBZUpm3Ob8YeDgihvrh7oaJiHvJPpheqXIs3gy8o8aqbwaWRcSeiHgSWAbMKzJnRNwdEYfyp8vJbmFWujp9OhiD2U40zEA5823Pe4DbmvX+gzXAdqnQcTqcC1Stu6lXb/hfdDd1oP9u6qXIDzGeBdxXY/F5klZLulNSmTcUDOBuSSskXVVj+WD6vUhXUP8PPpU+BZgRETvy6ceBGTXapNa3HyTbW67lcOOkKFfnhyMX1TkclVKfvgHYGREb6ywvpU+rtkuFjtPhXKBaiqRXAD8BPhkR1d8HspLsENUZwNeBnxccr9LrI2Iu2RdRfkzSBSVmGZCye0BeBvyoxuKU+vRFIjtOkvTltZKuBQ4B36vTJIVx8g3gJOBMYAfZ4bOUXcnAe0+F9+lA26UixulwLlAv527qaIC7qTebpNFkg+B7EfHT6uUR0RMR+/LppcBoSdMKjtmfZXv+cxfwM7JDJJUG0+9FeQuwMiJ2Vi9IqU9zO/sPheY/d9Vok0TfSno/8DbgvflG6iUGMU6aLiJ2RkRvRPQBN9XJkEqftgPvBBbXa1N0n9bZLhU6TodzgWqJu6nnx52/DWyIiK/UaXNM/7kxSeeQ/d7KKKQTJE3snyY7Yb62qtkS4H3KnAvsrTgkULS6/yNNpU8rVI7FBcDtNdrcBVwiaUp+uOqSfF5hJM0DPg1cFhH767QZzDhpuqpzn39eJ8NgthNFeBPwYERsq7Ww6D4dYLtU7Dgt4oqQsh5kV5Q9RHaVzrX5vM+R/XEBjCM7/LMJ+B1wYgkZX0+2m7wGWJU/LgU+Anwkb3M1sI7sCqPlwPkl9eeJeYbVeZ7+Pq3MKuDGvM8fADpLyjqBrOAcWTEviT4lK5o7gINkx+c/RHbu81fARuCXwNS8bSfwrYp1P5iP103AB0rIuYns/EL/WO2/CnYWsHSgcVJC1lvzMbiGbMM6szpr/vwl24kic+bzv9M/NivaltanA2yXCh2nvpOEmZklaTgf4jMzsxbmAmVmZklygTIzsyS5QJmZWZJcoMzMLEkuUGYFkXRUxV2rH6+40/Y+SX9Xdj6z1Pgyc7MSSLoe2BcRXyo7i1mqvAdlVjJl3031i3z6ekk3S/qNpK2S3inpC/n3AP1TfvsZJJ0t6V/yG4feVfId482awgXKLD0nAReR3ej2u8A9EfFa4FngrXmR+jpweUScDSwCPl9WWLNmaS87gJm9xJ0RcVDSA2RfqPdP+fwHgA7gFOA1wLL8doJtZLfPMRtWXKDM0vM8QET0SToY/36iuI/sb1bAuog4r6yAZkXwIT6z1vMHYLqk8yD7WoQEvnDRrOFcoMxaTGRfTX45cIOk1WR3mj6/1FBmTeDLzM3MLEnegzIzsyS5QJmZWZJcoMzMLEkuUGZmliQXKDMzS5ILlJmZJckFyszMkuQCZWZmSfr/084dPgvpxvoAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.subplot( 3, 1, 1)\n", "plt.plot( [sol1.t[0],time_x_on,time_x_on,sol3.t[-1]], [0,0,1,1] )\n", "plt.ylabel( \"X\")\n", "plt.subplot( 3, 1, 2)\n", "plt.plot( [sol1.t[0],time_y_on,time_y_on,sol3.t[-1]], [0,0,1,1] )\n", "plt.ylabel( \"Y\")\n", "\n", "plt.subplot( 3, 1, 3 )\n", "plt.plot(sol1.t, sol1.y.T); #Simulation before signal on\n", "plt.gca().set_prop_cycle(None) # this resets the color cycle\n", "plt.plot(sol2.t, sol2.y.T); #Simulation after X signal on\n", "plt.gca().set_prop_cycle(None) # this resets the color cycle\n", "plt.plot(sol3.t, sol3.y.T); #Simulation after X and Y signal on\n", "plt.xlabel( 'Time')\n", "plt.ylabel( \"Z\")\n", "plt.tight_layout()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Model a dual activator system with an OR gate\n", "\n", "There are now two factors X and Y. Both are activators and their effects are combined so that the presence of one or the other can activate transcription, but it is not as simple as just adding them together. This means the model's activation function is\n", "\n", "$\\beta (\\frac{(X/K_zx)^H}{1+(X/K_zy)^H+(Y/K_zy)^H} + \\frac{(Y/K_zy)^H}{1+(X/K_zy)^H+(Y/K_zy)^H})$\n", "\n", "where $\\beta$ is the maximal rate of transcription of Z, $H$ is the Hill coefficient (using the same value for both expressions, for the sake of simplicity), $K_{zx}$ is the activation threshold for X on Z, $K_{zy}$ is the activation threshold for Y on Z, and now $X$ and $Y$ are both parameters that will change over time.\n", "\n", "The full model is\n", "\n", "$\\frac{dZ}{dt} = \\beta (\\frac{(X/K_zx)^H}{1+(X/K_zy)^H+(Y/K_zy)^H} + \\frac{(Y/K_zy)^H}{1+(X/K_zy)^H+(Y/K_zy)^H}) - \\alpha Z$\n", "\n", "where $\\alpha$ is the degradation rate constant." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "def dual_activator_OR( t, statevars, params):\n", " Z = statevars[0]\n", " beta = params[0]\n", " H = params[1]\n", " Kzx = params[2]\n", " Kzy = params[3]\n", " alpha = params[4]\n", " X = params[5]\n", " Y = params[6]\n", " \n", " dstatevarsdt = np.zeros( (1,) )\n", " denom = 1 + (X/Kzx)**H + (Y/Kzy)**H\n", " dstatevarsdt[0] = beta * ((X/Kzx)**H/denom + (Y/Kzy)**H/denom) - alpha*Z\n", " return dstatevarsdt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Simulate the model\n", "\n", "Use $\\beta=1$, $K_{zx}=0.5$, $H=5$, $K_{zy}=0.5$, and $\\alpha=1$. X should be 0 until t=0.5, and 1 thereafter. Y should be 0 until t=5, and 1 thereafter. \n", "\n", "Simulate from t=0 to t=20 with a time steps of 0.01." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "# Assign each parameter a name by value\n", "beta = 1;\n", "Kzy = 0.5;\n", "Kzx = 0.5;\n", "H = 5;\n", "alpha = 1;\n", "\n", "# Set up parameters so that X is off, and then X is on, and then both X and Y are on.\n", "time_x_on = 0.5\n", "time_y_on = 5\n", "\n", "params_off = (beta, H, Kzx, Kzy, alpha,0,0);\n", "params_Xon = (beta, H, Kzx, Kzy, alpha,1,0);\n", "params_XYon = (beta, H, Kzx, Kzy, alpha,1,1);\n", "\n", "# Make versions of the model X,Y off/on pattern\n", "mf_off = lambda t,y : dual_activator_OR(t,y, params_off)\n", "mf_Xon = lambda t,y : dual_activator_OR(t,y, params_Xon)\n", "mf_XYon = lambda t,y : dual_activator_OR(t,y, params_XYon)\n", "\n", "# Simulate first with X off, then turn X on, then turn both on.\n", "sol1 = scipy.integrate.solve_ivp( fun=mf_off, t_span=(0,time_x_on), y0=(0,), \n", " t_eval=np.arange(0,time_x_on,.01) )\n", "sol2 = scipy.integrate.solve_ivp( fun=mf_Xon, t_span=(time_x_on,time_y_on), y0=sol1.y[:,-1], \n", " t_eval=np.arange(time_x_on,time_y_on,.01) )\n", "sol3 = scipy.integrate.solve_ivp( fun=mf_XYon, t_span=(time_y_on,20), y0=sol2.y[:,-1], \n", " t_eval=np.arange(time_y_on,20,.01) )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Plot the simulation\n", "\n", "Plot X over time in an upper subplot, Y over time in a middle subplot, and Z over time in a lower subplot." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.subplot( 3, 1, 1)\n", "plt.plot( [sol1.t[0],time_x_on,time_x_on,sol3.t[-1]], [0,0,1,1] )\n", "plt.ylabel( \"X\")\n", "plt.subplot( 3, 1, 2)\n", "plt.plot( [sol1.t[0],time_y_on,time_y_on,sol3.t[-1]], [0,0,1,1] )\n", "plt.ylabel( \"Y\")\n", "\n", "plt.subplot( 3, 1, 3 )\n", "plt.plot(sol1.t, sol1.y.T); #Simulation before signal on\n", "plt.gca().set_prop_cycle(None) # this resets the color cycle\n", "plt.plot(sol2.t, sol2.y.T); #Simulation after X signal on\n", "plt.gca().set_prop_cycle(None) # this resets the color cycle\n", "plt.plot(sol3.t, sol3.y.T); #Simulation after X and Y signal on\n", "plt.xlabel( 'Time')\n", "plt.ylabel( \"Z\")\n", "plt.tight_layout()" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "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.5" } }, "nbformat": 4, "nbformat_minor": 4 }