day02_python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 02\n",
    "## Introduction to Python and ODE Solver\n",
    "A web-based, interactive computing tool for capturing the whole computation process: developing, documenting, and executing code, as well as communicating the results.\n",
    "- Ctrl-Enter: run cell in-place\n",
    "- Shift-Enter: run cell\n",
    "- Alt-Enter: run cell, insert below\n",
    "\n",
    "Indentation matters!\n",
    "\n",
    "Capitalization is important!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here I am printing\n",
    "print(5)\n",
    "print(1+1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "When declaring a variable, capitalization is important!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "variable = 2.3\n",
    "Five = 5\n",
    "message = \"This is a string\"\n",
    "print (variable)\n",
    "print (Five + Five)\n",
    "print(variable,message,Five)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Message:\", message)\n",
    "print(\"%s string\" % message)\n",
    "print(\"%d int and %f float\" % (Five,variable))\n",
    "print(\"{} int and {} float\".format(Five,variable))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"hello\" + \"world\")\n",
    "print(\"number\" * 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"some\" + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (type(Five))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (type(variable))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "year=\"2020\"\n",
    "print(int(year)+1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arithmetic Operations\n",
    "\n",
    "Addition +\n",
    "\n",
    "Subtraction -\n",
    "\n",
    "Division /\n",
    "\n",
    "Multiplication *\n",
    "\n",
    "Modulo % (returns the remainder of a division)\n",
    "\n",
    "Floor division //\n",
    "\n",
    "The power of **"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(5%2)\n",
    "print(5/2)\n",
    "print(5//2)\n",
    "print(2**3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## if/else/elif\n",
    "\n",
    "- Equals: a == b\n",
    "- Not Equals: a != b\n",
    "- Less than: a < b\n",
    "- Less than or equal to: a <= b\n",
    "- Greater than: a > b\n",
    "- Greater than or equal to: a >= b\n",
    "\n",
    "- Not Equals AND a greater than 0: a!= and a>0\n",
    "- Not Equals OR a greater than 0: a!= or a>0\n",
    "\n",
    "Indentation matters!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=2\n",
    "b=5\n",
    "if a>b:\n",
    "    print(\"a is bigger than b\")\n",
    "elif a<b:\n",
    "    print(\"a is smaller than b\")\n",
    "else:\n",
    "    print(\"a is equal to b\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if a>b:\n",
    "    print(\"a is bigger than b\")\n",
    "elif a<b:\n",
    "    print(\"a is smaller than b\")\n",
    "    if a>0:\n",
    "        print(\"a is positive\")\n",
    "else:\n",
    "    print(\"a is equal to b\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "- store an integer number in a variable.\n",
    "- determine if the number is even or odd.\n",
    "\n",
    "Tip: if, else, %"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops\n",
    "Indentation is IMPORTANT!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in range(0,3):\n",
    "    print(\"x = %d\" % x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in range(0,3):\n",
    "    for y in range(0,3):\n",
    "        print(\"(x,y) = (%d,%d)\" % (x,y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise\n",
    "Using a for loop, for $1\\leq x\\leq 5$ and $1\\leq y\\leq 5$, print when $x*y$ is even\n",
    "\n",
    "Tip: for, range(), if, %"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = [\"first\", \"second\", 3]\n",
    "print(mylist[0], mylist[2])\n",
    "print(mylist)\n",
    "print(type(mylist))\n",
    "print(type(mylist[0]))\n",
    "print(type(mylist[2]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist[1]=2.0\n",
    "mylist.append(\"LNCC\")\n",
    "for item in mylist:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuple\n",
    "A tuple is a collection which is ordered and unchangeable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mytuple = (\"apple\", \"banana\", 3)\n",
    "for item in mytuple:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mytuple[1]=3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## User defined functions\n",
    "User-defined functions are reusable code blocks; they only need to be written once, then they can be used multiple times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def addNumbers(n1,n2,n3):\n",
    "    result = n1+n2+n3\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "total=addNumbers(2,4,5)\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise\n",
    "Write a user defined function that accepts x and y and returns:\n",
    "\\begin{equation}\n",
    "(x+y)^2\n",
    "\\end{equation}\n",
    "Test your function!\n",
    "\n",
    "Tip: def, **, return, print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Anonymous Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = lambda a: a*10\n",
    "print(x(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myfunc(x):\n",
    "    return lambda a: a*x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y=myfunc(10)\n",
    "print(y(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z=myfunc(100)\n",
    "print(z(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Importing functions from other files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import veraolncc as lncc\n",
    "total = lncc.soma_tres(2,5,8)\n",
    "print(total)\n",
    "total = lncc.soma_quad(2,5)\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining the model\n",
    "Let N be the number of tumor cells and assume that this number can increase with a growth rate of $r$ 1/hour until it reaches the environmental carrying capacity of $K$ cells. With these assumptions, the mathematical model is:\n",
    "\\begin{equation}\n",
    "\\frac{dN}{dt}=rN\\left(1-\\frac{N}{K}\\right),\n",
    "\\end{equation}\n",
    "\n",
    "- $r$: tumor growth rate;\n",
    "- $K$: environmental carrying capacity;\n",
    "- $\\boldsymbol{p}=(r,K)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let y be the vector of outputs, t the time, and p the vector of parameters\n",
    "def control_tumor(y, t, p):\n",
    "    tumor = p[0] * y[0] * (1.0 - y[0] / p[1])\n",
    "    return tumor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing libraries\n",
    "import numpy as np\n",
    "from scipy.integrate import odeint\n",
    "# Define time interval, parameter value, and initial condition\n",
    "times = np.arange(0,50,0.5)\n",
    "r = 0.25\n",
    "K = 60\n",
    "ic = 1\n",
    "# Solving the ODE model\n",
    "sol = odeint(control_tumor, t=times, y0=ic, args=tuple([[r,K]]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plotting the solution\n",
    "import matplotlib.pyplot as plt\n",
    "fig, ax = plt.subplots(dpi=120)\n",
    "plt.plot(times, sol, label='Logistic Model', color='red',linewidth=2.0)\n",
    "plt.legend()\n",
    "plt.xlabel('Time (hours)')\n",
    "plt.ylabel('Cell number');\n",
    "#plt.savefig(\"just_data.pdf\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding drug\n",
    "Let C be the drug concentration (ng/mL) and assume that: it is being constantly delivered at a rate $a$, it naturally decays at a rate $b$, and it is consumed by the tumor by a rate $g$. The number of cells will decrease proportionally to the drug concentration at a rate $f$. With these assumptions, the mathematical model is:\n",
    "\\begin{align}\n",
    "\\frac{dN}{dt}&=rN\\left(1-\\frac{N}{K}\\right)-fNC,\\\\\n",
    "\\frac{dC}{dt}&=a-bC-gNC.\n",
    "\\end{align}\n",
    "\n",
    "- $r$: tumor growth rate;\n",
    "- $K$: environmental carrying capacity;\n",
    "- $f$: tumor death rate due to the drug;\n",
    "- $a$: drug delivery;\n",
    "- $b$: drug natural decay;\n",
    "- $g$: drug consumption rate;\n",
    "- $\\boldsymbol{p}=(r,K,f,a,b,g)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#p = (r,K,f,a,b,g)\n",
    "def treated_tumor(y, t, p):\n",
    "    tumor=p[0] * y[0] * (1.0 - y[0] / p[1])-p[2]*y[0]*y[1]\n",
    "    drug=p[3]-p[4]*y[1]-p[5]*y[0]*y[1]\n",
    "    return [tumor,drug]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define time interval, parameter value, and initial condition\n",
    "times = np.arange(0,50,0.5)\n",
    "r = 0.25\n",
    "K = 60\n",
    "f = 0.1\n",
    "a = 1.0\n",
    "b = 0.1\n",
    "g = 0.2\n",
    "tumor_ic = 1\n",
    "drug_ic = 0\n",
    "# Solving the ODE model\n",
    "y = odeint(treated_tumor, t=times, y0=[tumor_ic,drug_ic], args=tuple([[r,K,f,a,b,g]]))\n",
    "sol = odeint(control_tumor, t=times, y0=tumor_ic, args=tuple([[r,K]]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plotting the tumor solution\n",
    "fig, ax = plt.subplots(dpi=120)\n",
    "plt.plot(times, sol, label='Control Tumor', color='red',linewidth=2.0)\n",
    "plt.plot(times, y[:,0], label='Treated Tumor', color='black',linewidth=2.0)\n",
    "plt.legend()\n",
    "plt.xlabel('Time (hours)')\n",
    "plt.ylabel('Cell number');\n",
    "#plt.savefig(\"just_data.pdf\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plotting the drug solution\n",
    "fig, ax = plt.subplots(dpi=120)\n",
    "plt.plot(times, y[:,1], label='Drug', color='red',linewidth=2.0)\n",
    "plt.legend()\n",
    "plt.xlabel('Time (hours)')\n",
    "plt.ylabel('Drug Concentration');\n",
    "#plt.savefig(\"just_data.pdf\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise\n",
    "Let C be the drug concentration (ng/mL) and assume that: it is being constantly delivered at a rate $a$, it naturally decays at a rate $b$, and it is consumed by the tumor by a rate $g$. Let $D$ be the tumor cells that lost the hability to proliferate due to the drug at a rate $f$. With these assumptions, the mathematical model is:\n",
    "\\begin{align}\n",
    "\\frac{dN}{dt}&=rN\\left(1-\\frac{N+D}{K}\\right)-fNC,\\\\\n",
    "\\frac{dC}{dt}&=a-bC-gNC-gDC,\\\\\n",
    "\\frac{dD}{dt}&=fNC.\n",
    "\\end{align}\n",
    "\n",
    "- $r$: tumor growth rate;\n",
    "- $K$: environmental carrying capacity;\n",
    "- $f$: proliferation inhibition due to the drug;\n",
    "- $a$: drug delivery;\n",
    "- $b$: drug natural decay;\n",
    "- $g$: drug consumption rate;\n",
    "- $\\boldsymbol{p}=(r,K,f,a,b,g)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}