Lec03-simple-functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "84f2ab74-7c1e-4385-92d5-0b6bd4d14fdd",
   "metadata": {},
   "source": [
    "### Getting started with functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3416a4c7-895a-4ed8-a34f-39b703f1b763",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a really simple function\n",
    "# the keyword \"def\" denotes the start of a function definition\n",
    "# it is followed by function name and arguments and then a :\n",
    "# \n",
    "# Function definition is all the indented lines after the :\n",
    "# \n",
    "def printhi():\n",
    "    print(\"hi\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73e0af9d-5eb6-4ea9-a5ee-55e343a4e0fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# To invoke a function use its name followed by parentheses.\n",
    "# This executes the code in the function\n",
    "printhi()\n",
    "printhi()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "705b40a8-1488-4fb2-b46a-48c248260d46",
   "metadata": {},
   "source": [
    "##### Functions can also take arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0ceead1-ae6a-4454-b193-07bdee4305b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here there is a required argument name, that is used in the print statement.\n",
    "# It can be different for each call of the function.\n",
    "def printhiname(name):\n",
    "    print(\"hi\", name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48bd09b2-0730-414b-8815-f67a73ada8ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "printhiname(\"Chris\")\n",
    "printhiname(\"Tom\")\n",
    "printhiname()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f8ecfd8-da04-4616-8eda-a91feef70f23",
   "metadata": {},
   "source": [
    "##### Argments are required by default, but this can be altered by providing a default value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bfacd3fa-43ac-45b5-83ba-372b8676655f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here is an example of adding a default value for a function argument\n",
    "def printhiname(name=\"NO NAME\"):\n",
    "    print(\"hi\", name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d6ac1a96-91ec-454b-9914-e263fae2631d",
   "metadata": {},
   "outputs": [],
   "source": [
    "printhiname()\n",
    "printhiname(\"Chris\")\n",
    "printhiname(name=\"Chris\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36d315f3-0b41-4151-a7c2-7c04df027c9f",
   "metadata": {},
   "source": [
    "##### Functions can return computation results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ee666a9-63c2-4129-b6f5-e60dc98a4b7c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calc_sum(arr):\n",
    "    asum=0.\n",
    "    for aval in arr:\n",
    "        asum=asum+aval\n",
    "    return asum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36d9b495-386d-4dc9-bdc7-04eb4bb1efa5",
   "metadata": {},
   "outputs": [],
   "source": [
    "calc_sum([0,1,2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3869eb9d-e525-4c6c-bf25-2e0ea30311b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "#\n",
    "# Now lets define a function for plotting sea-level that we can use for any location\n",
    "#\n",
    "def plot_sl(scode=\"WOODS\"):\n",
    "    \"\"\" A function to plot the time-series of tide-gauge water level measurments (relative\n",
    "    to local solid Earth) for historical data at the tide gauge archive https://www.psmsl.org.\n",
    "    \"\"\"\n",
    "    import pandas\n",
    "    import matplotlib.pyplot as plt\n",
    "    station_list=pandas.read_html(\"https://www.psmsl.org/data/obtaining/\")[0]\n",
    "    \n",
    "    matched_stations=station_list[station_list['Station Name'].str.contains(scode)==True]\n",
    "    ls=len(matched_stations)\n",
    "    print(ls,\"matching stations found.\")\n",
    "    \n",
    "    if ls == 0:\n",
    "        return\n",
    "    \n",
    "    if ls > 1:\n",
    "        for i,r in matched_stations.iterrows():\n",
    "            print(\"%-30.30s %s\"%(r[\"Station Name\"],r[\"Country\"]))\n",
    "        return\n",
    "    \n",
    "    # Here we only have 1 station so we can make a plot\n",
    "    snum=matched_stations[\"ID\"]\n",
    "    surl=\"http://www.psmsl.org/data/obtaining/rlr.monthly.data/%d.rlrdata\"%(snum)\n",
    "    df = pandas.read_csv(surl,delimiter=';')\n",
    "    df=df[df.iloc[:,1]>=-1000]\n",
    "    npdat =df.to_numpy()\n",
    "    t=npdat[:,0];h=npdat[:,1]\n",
    "    plt.rcParams['figure.figsize'] = [20, 10]\n",
    "    plt.plot(t,(h-h[0])/10); \n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aab8e035-f400-4c23-a69e-7e8a276a8685",
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_sl(\"BOSTON\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce6226f3-2582-4a5b-8ecb-37075b9b228d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lets show the doc string\n",
    "plot_sl?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a7dbcd46-555e-4661-a1bf-ebdd5b0ae16e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# One final piece of function syntax\n",
    "def print_vars(*args):\n",
    "    for a in args:\n",
    "        print(a)\n",
    "    return\n",
    "\n",
    "print_vars(1)\n",
    "print(\"\")\n",
    "print_vars(1,2)\n",
    "\n",
    "print(\"\")\n",
    "\n",
    "def print_vars_with_kw(*args,**kwargs):\n",
    "    for a in args:\n",
    "        print(a)\n",
    "    print(kwargs.keys())\n",
    "    print(kwargs[\"x\"])\n",
    "          \n",
    "    return\n",
    "\n",
    "print_vars_with_kw(1,x=7)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe8c73a4-8720-4936-967f-bab0d34d9df2",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### Now lets look functions for solving some equations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d99fbd9-8721-4ab3-ad10-f693060769fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# First a simple recursive function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf2b1154-dbfc-4eb4-92ad-bff45e607f3c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function calls itself recursvely with n reduced by 1 each time until n is 1.\n",
    "def factorial(n):\n",
    "    if n==1 or n==0:\n",
    "        return 1\n",
    "    else:\n",
    "        return n * factorial(n-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "55cd1a95-f4ac-492d-a7f1-0ae1ad2f6f59",
   "metadata": {},
   "outputs": [],
   "source": [
    "factorial(23)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04fe9394-bb6d-47ed-a253-dc13e2b7e526",
   "metadata": {},
   "source": [
    "#### Using functions to make a Lorenz 63 \"butterfly\" plot \n",
    "( https://en.wikipedia.org/wiki/Lorenz_system )\n",
    "\n",
    "Lorenz 63 is a system of 3 equations devepoed by Ed Lorenz ( https://en.wikipedia.org/wiki/Edward_Norton_Lorenz ) in build 54 in the 1960's, with computhing help from Ellen Fetter ( https://en.wikipedia.org/wiki/Ellen_Fetter ). The system is famous for being a very simple demonstration of a \"chaotic\" system. \n",
    "\n",
    "A chaotic system is a system in which a very small change in the initial conditions can get amplified in an unpredictable way so that two \"trajectories\" that are initially close separate to become very different. In a chaotic system, after some time, the difference between two similar but slight different initial trajectories is not proportional to the initial difference. \n",
    "\n",
    "Lorenz defined a system of 3 hypothetical variables, $x,y,z$ that vary in time, $t$ in relation to one another according to the equations\n",
    "\n",
    "$$\\begin{align}\n",
    "\\frac{dx}{dt} & =  \\sigma(x-y)  \\\\\n",
    "\\frac{dy}{dt} & =  x(\\rho-z)-y  \\\\\n",
    "\\frac{dz}{dt} & = xy-\\beta z\n",
    "\\end{align}$$\n",
    "\n",
    "with parameters, $\\sigma, \\rho, \\beta$, constant in time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6cde4b19-4672-4b01-9580-ee592c3aeb63",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lets write a function to evaluate the Lorenz 63 equations\n",
    "def lorenz63( x, y, z, σ=10., ρ=28., β=8./3. ):\n",
    "    \"\"\"\n",
    "    Function to evaluate the Lorenz 63 time derivative equation for a given current\n",
    "    state and parameters.\n",
    "    Arguments:\n",
    "    x, y, z: x,y,z values.\n",
    "    σ, ρ, β: static parameters α, ρ and β.\n",
    "    \"\"\"\n",
    "    xt=σ*(y-x)\n",
    "    yt=x*ρ-x*z-y\n",
    "    zt=x*y-β*z\n",
    "    return xt,yt,zt\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17294cab-d427-424f-b170-8c1a0d578d71",
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y,z=1,1,1;\n",
    "dxdt,dydt,dzdt=lorenz63( x, y, z )\n",
    "print(dxdt,dydt,dzdt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce2872af-8895-40b1-8895-3e6babd1a8cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "lorenz63?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "667f9e29-6de4-4f21-9a32-4b0c42e99544",
   "metadata": {},
   "source": [
    "For given initial conditions, we can simulate the time evolution of the Lorenz 63 system using the same sort\n",
    "of timestepping we looked at in Lecture 1.\n",
    "$$\n",
    "\\phi^{n+1}=\\phi^{n}+\\Delta t f(\\phi^{n})\n",
    "$$\n",
    "this is not a very accurate numerical scheme (it is called an Euler forward scheme), so we will look at other schemes later. For illustrating programming concepts here it is usable.\n",
    "\n",
    "In the Lorenz 63 case $\\phi$ will be our array of time evolving values $x,y$ and $z$, and the function $f()$ can be our ``lorenz63`` Python function we just looked at."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17c73e36-c061-4fda-af28-5bf45cb8a726",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lets try this\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from mpl_toolkits import mplot3d\n",
    "\n",
    "x0,y0,z0=0.,1.,1.05; Δt=0.01 # Initial conditions and paramteres (note we need a discrete timestep)\n",
    "nsteps=10000;\n",
    "x=np.zeros(nsteps+1);x[0]=x0\n",
    "y=np.zeros(nsteps+1);y[0]=y0\n",
    "z=np.zeros(nsteps+1);z[0]=z0\n",
    "for i in range(nsteps):\n",
    "        dxdt,dydt,dzdt=lorenz63( x[i], y[i], z[i] )\n",
    "        x[i+1]=x[i]+dxdt*Δt\n",
    "        y[i+1]=y[i]+dydt*Δt\n",
    "        z[i+1]=z[i]+dzdt*Δt\n",
    "        \n",
    "ax=plt.axes(projection='3d')\n",
    "ax.scatter3D(x,y,z,s=0.5);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4bc7c02d-0005-44a9-ada4-e90995e53326",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(x);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8348a013-7ce1-4d65-8cc9-52c467c604c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can go a bit further with functions by defining a \"timestepping\" function for the Euler forward scheme we are using\n",
    "# and passing the time-derivative function as an argument to a generic stepper.\n",
    "def euler_forward_stepper(f, u0,nt,dt, params={}):\n",
    "    \"\"\"\n",
    "    Function euler_forward_stepper steps forward for n steps a set of discrete ODE equations\n",
    "    using an Euler forward scheme.\n",
    "    Arguments:\n",
    "    f: Function that returns time-derivative at current value of the state, u.\n",
    "       f is expected to have each component of u as a separate argument, followed\n",
    "       by keyword arguments for named parameters.\n",
    "    u0: Initial values for the components of u\n",
    "    nsteps: number of steps to take\n",
    "    dt: time-step\n",
    "    params: Dictionary of parameter settings, set using keywords.\n",
    "    \"\"\"\n",
    "    # Set up initial state\n",
    "    nf=len(u0)\n",
    "    u=np.zeros( (nt+1,nf) )\n",
    "    dudt=np.zeros( nf )\n",
    "    for i in range(nf):\n",
    "        u[0,i]=u0[i]\n",
    "        \n",
    "    # Step forward\n",
    "    for n in range(nt):\n",
    "        dudt=f(*u[n,:],**params)\n",
    "        u[n+1,:]=u[n,:]+np.array(dudt)*dt\n",
    "        \n",
    "    # return result\n",
    "    return u"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7360aee1-e5ba-4f17-a034-c9e932cce516",
   "metadata": {},
   "outputs": [],
   "source": [
    "nsteps=10000;\n",
    "dt=0.01;\n",
    "eps=1.e-4;\n",
    "u0=euler_forward_stepper(lorenz63, np.array([0.,1.,1.05]), nsteps, dt);\n",
    "u1=euler_forward_stepper(lorenz63, np.array([0.+eps,1.,1.05]), nsteps, dt);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6703c359-b696-4fc7-8757-d9968b3fa16e",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(u0[:,0]);plt.plot(u1[:,0]);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2a47d19-3e08-4f1a-b9b1-2b2871a3c7ba",
   "metadata": {},
   "source": [
    "##### This plot demonstrates why computer weather forecasts get less accurate with time. Can you think why the plot shows this!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ab78217e-cb0e-40ea-a16c-40816ce9c4bd",
   "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}