{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ChEn-1070: Introduction to Chemical Engineering Fall 2019 UMass Lowell; Profs. Manohar and de Almeida **10Sep2019**\n",
    "\n",
    "# 01. Introduction to Jupyter Notebooks and Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Table of Contents\n",
    "* [Inspiration](#nasa)\n",
    "* [What is a Jupyter Notebook?](#whatisit)\n",
    "* [Access to a JNotebook server](#access)\n",
    "* [Jupyter Notebook cell](#jnbcell)\n",
    "    + [Markdown text](#markdown)\n",
    "    + [Execute Python code](#execute)\n",
    "    + [Inspect Python variables](#variables)\n",
    "* [Additional help](#umllinux)\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inspiration<a id=\"nasa\"></a>\n",
    "*Lines of python code*:\n",
    " - [We are NASA (\"men in the moon\")](https://www.youtube.com/watch?v=WeA7edXsU40&app=desktop) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is a Jupyter Notebook?<a id=\"whatisit\"></a>\n",
    "A web application for presenting code, results, and discussion (analysis) all in one place. There are many sources to learn additional information from, such as:\n",
    " 1. [Visit the website](http://jupyter.org/) \n",
    " 1. [Read the basic documentation](https://jupyter-notebook.readthedocs.io/en/stable/index.html)\n",
    " 1. [Try examples first](https://jupyter-notebook.readthedocs.io/en/stable/examples/Notebook/examples_index.html)\n",
    " 1. [Recent Journal Article](https://www.nature.com/articles/d41586-018-07196-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Access to a Jupyter Notebook<a id=\"access\"></a>\n",
    " 1. Use the web-based cloud service [Azure](https://notebooks.azure.com/). Login with your student UMass Lowell student credential and start a Jupyter Notebook. This is a **free** Microsoft cloud service.\n",
    " 2. Access [this repository](https://github.com/dpploy/chen-1070) and use its Binder deployment of a Jupyter Notebook server.\n",
    " 3. Install [Anaconda](https://docs.anaconda.com/anaconda/install/#) (free download) and use (Mac OS X and Windows) the Python 3 tarball. After install, use [Anaconda-Navigator](https://docs.anaconda.com/anaconda/navigator/) to start a Jupyter Notebook server."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    " ## Jupyter Notebook cell: the basic concept<a id=\"jnbcell\"></a>\n",
    "\n",
    "### Writing your document (`this cell`)<a id=\"markdown\"></a>\n",
    "Have you seen this formula before?    \n",
    "\\begin{equation}\n",
    "k = k_0 \\, e^{-\\frac{E_a}{RT}}.\n",
    "\\end{equation}    \n",
    "How about typesetting formula in text: $\\ln k = \\ln k_0 - \\frac{E_a}{RT}$? How was this done?\n",
    "\n",
    "All of this text was written in Jupyter Markdown markup language and rendered via executing **this cell**. If you double click on this cell, you will see the Markdown source file. Then execute `Run` on the cell to render it again.\n",
    "\n",
    "### Markdown links\n",
    "[Jupyter Markdown markup language](https://jupyter-notebook.readthedocs.io/en/stable/examples/Notebook/Working%20With%20Markdown%20Cells.html).\n",
    "\n",
    "[More on Jupyter Markdown markup language](https://sourceforge.net/p/jupiter/wiki/markdown_syntax/).\n",
    "\n",
    "[Additional on Jupyter Markdown markup language](http://assemble.io/docs/Cheatsheet-Markdown.html).\n",
    "\n",
    "[Useful extensions and colored boxes](https://www.ibm.com/support/knowledgecenter/en/SSQNUZ_1.1.0/dsx/markd-jupyter.html)\n",
    "\n",
    "[Markdown project (see markdown render tool)](https://daringfireball.net/projects/markdown/)\n",
    "\n",
    "NB: you can export the notebook to different formats (Menu Bar: file -> Download as ->).\n",
    "\n",
    "### Markdown your code (*fenced code block with language highlighting*; double click here)\n",
    "\n",
    "Here is a plotting example from the [Matplotlib site](https://matplotlib.org/index.html):\n",
    " ```python\n",
    " import matplotlib.pyplot as plt  # this is an import of the package\n",
    " plt.plot([1,2,3,4])\n",
    " plt.ylabel('some numbers')\n",
    " plt.show()\n",
    " ```\n",
    "this Python code will be executed in the next cell, the last line of source code will display the x-y plot."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Execute your Python code<a id=\"execute\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot([1,2,3,4])\n",
    "plt.ylabel('some numbers')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's use another code plotting script:\n",
    "```python\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def f(t):\n",
    "    return np.exp(-t) * np.cos(2*np.pi*t)\n",
    "\n",
    "t1 = np.arange(0.0, 5.0, 0.1)\n",
    "t2 = np.arange(0.0, 5.0, 0.02)\n",
    "\n",
    "plt.figure(1)\n",
    "plt.subplot(211)\n",
    "plt.plot(t1, f(t1), 'bo', t2, f(t2), 'k')\n",
    "\n",
    "plt.subplot(212)\n",
    "plt.plot(t2, np.cos(2*np.pi*t2), 'r--')\n",
    "plt.show()\n",
    "```\n",
    "and execute the next cell to obtain the plot below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "'''\n",
    "This is an example of two stacked plots using\n",
    "the subplot() method of the pyplot package.\n",
    "'''\n",
    "import numpy as np               # import the numpy package for arrays computation\n",
    "import matplotlib.pyplot as plt  # import the matplotlib package for plotting\n",
    "\n",
    "def f(t):\n",
    "    '''\n",
    "    Define a decaying cosine function\n",
    "    '''\n",
    "    return np.exp(-t) * np.cos(2*np.pi*t)\n",
    "\n",
    "t1 = np.arange(0.0, 5.0, 0.1)\n",
    "t2 = np.arange(0.0, 5.0, 0.02)\n",
    "\n",
    "plt.figure(1)\n",
    "plt.subplot(211)\n",
    "plt.plot(t1, f(t1), 'bo', t2, f(t2), 'k')\n",
    "\n",
    "plt.subplot(212)\n",
    "plt.plot(t2, np.cos(2*np.pi*t2), 'r--')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inspecting Python variables<a id=\"variables\"></a>\n",
    "#### `t1` is a [NumPy](http://www.numpy.org/) `ndarray` (n-dimensional array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "t1 =  [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.  1.1 1.2 1.3 1.4 1.5 1.6 1.7\n",
      " 1.8 1.9 2.  2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9 3.  3.1 3.2 3.3 3.4 3.5\n",
      " 3.6 3.7 3.8 3.9 4.  4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9]\n"
     ]
    }
   ],
   "source": [
    "print(type(t1))\n",
    "print('t1 = ',t1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Use the help() command on the `f` function to access its _docstring_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function f in module __main__:\n",
      "\n",
      "f(t)\n",
      "    Define a decaying cosine function\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### What does this `plt.subplot(211)` mean? Use help to access documentation if any:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function subplot in module matplotlib.pyplot:\n",
      "\n",
      "subplot(*args, **kwargs)\n",
      "    Add a subplot to the current figure.\n",
      "    \n",
      "    Wrapper of `.Figure.add_subplot` with a difference in behavior\n",
      "    explained in the notes section.\n",
      "    \n",
      "    Call signatures::\n",
      "    \n",
      "       subplot(nrows, ncols, index, **kwargs)\n",
      "       subplot(pos, **kwargs)\n",
      "       subplot(ax)\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    *args\n",
      "        Either a 3-digit integer or three separate integers\n",
      "        describing the position of the subplot. If the three\n",
      "        integers are *nrows*, *ncols*, and *index* in order, the\n",
      "        subplot will take the *index* position on a grid with *nrows*\n",
      "        rows and *ncols* columns. *index* starts at 1 in the upper left\n",
      "        corner and increases to the right.\n",
      "    \n",
      "        *pos* is a three digit integer, where the first digit is the\n",
      "        number of rows, the second the number of columns, and the third\n",
      "        the index of the subplot. i.e. fig.add_subplot(235) is the same as\n",
      "        fig.add_subplot(2, 3, 5). Note that all integers must be less than\n",
      "        10 for this form to work.\n",
      "    \n",
      "    projection : {None, 'aitoff', 'hammer', 'lambert', 'mollweide', 'polar', 'rectilinear', str}, optional\n",
      "        The projection type of the subplot (`~.axes.Axes`). *str* is the name\n",
      "        of a costum projection, see `~matplotlib.projections`. The default\n",
      "        None results in a 'rectilinear' projection.\n",
      "    \n",
      "    polar : boolean, optional\n",
      "        If True, equivalent to projection='polar'.\n",
      "    \n",
      "    sharex, sharey : `~.axes.Axes`, optional\n",
      "        Share the x or y `~matplotlib.axis` with sharex and/or sharey. The\n",
      "        axis will have the same limits, ticks, and scale as the axis of the\n",
      "        shared axes.\n",
      "    \n",
      "    label : str\n",
      "        A label for the returned axes.\n",
      "    \n",
      "    Other Parameters\n",
      "    ----------------\n",
      "    **kwargs\n",
      "        This method also takes the keyword arguments for\n",
      "        the returned axes base class. The keyword arguments for the\n",
      "        rectilinear base class `~.axes.Axes` can be found in\n",
      "        the following table but there might also be other keyword\n",
      "        arguments if another projection is used.\n",
      "          adjustable: {'box', 'datalim'}\n",
      "      agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "      alpha: float\n",
      "      anchor: 2-tuple of floats or {'C', 'SW', 'S', 'SE', ...}\n",
      "      animated: bool\n",
      "      aspect: {'auto', 'equal'} or num\n",
      "      autoscale_on: bool\n",
      "      autoscalex_on: bool\n",
      "      autoscaley_on: bool\n",
      "      axes_locator: Callable[[Axes, Renderer], Bbox]\n",
      "      axisbelow: bool or 'line'\n",
      "      clip_box: `.Bbox`\n",
      "      clip_on: bool\n",
      "      clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None] \n",
      "      contains: callable\n",
      "      facecolor: color\n",
      "      fc: color\n",
      "      figure: `.Figure`\n",
      "      frame_on: bool\n",
      "      gid: str\n",
      "      in_layout: bool\n",
      "      label: object\n",
      "      navigate: bool\n",
      "      navigate_mode: unknown\n",
      "      path_effects: `.AbstractPathEffect`\n",
      "      picker: None or bool or float or callable\n",
      "      position: [left, bottom, width, height] or `~matplotlib.transforms.Bbox`\n",
      "      rasterization_zorder: float or None\n",
      "      rasterized: bool or None\n",
      "      sketch_params: (scale: float, length: float, randomness: float) \n",
      "      snap: bool or None\n",
      "      title: str\n",
      "      transform: `.Transform`\n",
      "      url: str\n",
      "      visible: bool\n",
      "      xbound: unknown\n",
      "      xlabel: str\n",
      "      xlim: (left: float, right: float)\n",
      "      xmargin: float greater than -0.5\n",
      "      xscale: {\"linear\", \"log\", \"symlog\", \"logit\", ...}\n",
      "      xticklabels: List[str]\n",
      "      xticks: list\n",
      "      ybound: unknown\n",
      "      ylabel: str\n",
      "      ylim: (bottom: float, top: float)\n",
      "      ymargin: float greater than -0.5\n",
      "      yscale: {\"linear\", \"log\", \"symlog\", \"logit\", ...}\n",
      "      yticklabels: List[str]\n",
      "      yticks: list\n",
      "      zorder: float\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    axes : an `.axes.SubplotBase` subclass of `~.axes.Axes` (or a subclass     of `~.axes.Axes`)\n",
      "    \n",
      "        The axes of the subplot. The returned axes base class depends on\n",
      "        the projection used. It is `~.axes.Axes` if rectilinear projection\n",
      "        are used and `.projections.polar.PolarAxes` if polar projection\n",
      "        are used. The returned axes is then a subplot subclass of the\n",
      "        base class.\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    Creating a subplot will delete any pre-existing subplot that overlaps\n",
      "    with it beyond sharing a boundary::\n",
      "    \n",
      "        import matplotlib.pyplot as plt\n",
      "        # plot a line, implicitly creating a subplot(111)\n",
      "        plt.plot([1,2,3])\n",
      "        # now create a subplot which represents the top plot of a grid\n",
      "        # with 2 rows and 1 column. Since this subplot will overlap the\n",
      "        # first, the plot (and its axes) previously created, will be removed\n",
      "        plt.subplot(211)\n",
      "    \n",
      "    If you do not want this behavior, use the `.Figure.add_subplot` method\n",
      "    or the `.pyplot.axes` function instead.\n",
      "    \n",
      "    If the figure already has a subplot with key (*args*,\n",
      "    *kwargs*) then it will simply make that subplot current and\n",
      "    return it.  This behavior is deprecated. Meanwhile, if you do\n",
      "    not want this behavior (i.e., you want to force the creation of a\n",
      "    new suplot), you must use a unique set of args and kwargs.  The axes\n",
      "    *label* attribute has been exposed for this purpose: if you want\n",
      "    two subplots that are otherwise identical to be added to the figure,\n",
      "    make sure you give them unique labels.\n",
      "    \n",
      "    In rare circumstances, `.add_subplot` may be called with a single\n",
      "    argument, a subplot axes instance already created in the\n",
      "    present figure but not in the figure's list of axes.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    .Figure.add_subplot\n",
      "    .pyplot.subplots\n",
      "    .pyplot.axes\n",
      "    .Figure.subplots\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    ::\n",
      "    \n",
      "        plt.subplot(221)\n",
      "    \n",
      "        # equivalent but more general\n",
      "        ax1=plt.subplot(2, 2, 1)\n",
      "    \n",
      "        # add a subplot with no frame\n",
      "        ax2=plt.subplot(222, frameon=False)\n",
      "    \n",
      "        # add a polar subplot\n",
      "        plt.subplot(223, projection='polar')\n",
      "    \n",
      "        # add a red subplot that shares the x-axis with ax1\n",
      "        plt.subplot(224, sharex=ax1, facecolor='red')\n",
      "    \n",
      "        #delete ax2 from the figure\n",
      "        plt.delaxes(ax2)\n",
      "    \n",
      "        #add ax2 to the figure again\n",
      "        plt.subplot(ax2)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(plt.subplot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## _Commercial:_...\n",
    "## Interested in Python development? Join us at [Cortix](https://cortix.org) for collaboratory coding.\n",
    "\n",
    "![](images/cortix-cover.png)\n",
    "\n",
    "## UMass Lowell Innovation Hub, 110 Canal, 3rd floor, room 318, Lowell, Fridays, 4:00pm, UML Linux Group; joing the [google group](https://groups.google.com/forum/#!forum/uml-linux).<a id=\"umllinux\"></a>\n"
   ]
  },
  {
   "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.7.1"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}