HW01.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Homework 1: Introduction to Python\n",
    "\n",
    "The first homework problem is solved with Excel and Python. Most of the Python solution is provided with a tutorial on elements that you'll need to complete this assignment. The following topics are covered:\n",
    "\n",
    "* install Python\n",
    "* help, print, type\n",
    "* variable names\n",
    "* functions\n",
    "* operators\n",
    "* import packages\n",
    "* introduction to numpy\n",
    "* introduction to matplotlib\n",
    "\n",
    "The following code is to display YouTube videos and URL links in the Notebook. There is no need to modify this code. Look for places where an ***Action*** is required."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function to display YouTube videos and external web-pages\n",
    "from IPython.core.display import display, HTML\n",
    "def video(key):\n",
    "    display(HTML('<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/'+key+'\" \\\n",
    "             frameborder=\"0\" allow=\"autoplay; encrypted-media\" allowfullscreen></iframe>'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 1\n",
    "\n",
    "Install Python if you have a laptop computer. If not, then skip this step and use Google Colab instead.\n",
    "\n",
    "***Action 1a:*** Download and install Python (IDLE) from https://www.python.org/downloads/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/bXWlyOMYpRE\"              frameborder=\"0\" allow=\"autoplay; encrypted-media\" allowfullscreen></iframe>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "video('bXWlyOMYpRE')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Action 1b:*** Download and install Python (Jupyter Notebook, Spyder) from https://www.anaconda.com/distribution/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/LrMOrMb8-3s\"              frameborder=\"0\" allow=\"autoplay; encrypted-media\" allowfullscreen></iframe>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "video('LrMOrMb8-3s')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Getting Started\n",
    "\n",
    "Some of the most useful things for getting started are to use ```print()```, ```help()```, and know how to search for answers online in forums such as <a href='https://stackoverflow.com/questions/tagged/python' target='_blank'>StackOverflow</a> or with a search engine.\n",
    "\n",
    "***Action 1c:*** Change ```'my message'``` to a different text message."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my message\n"
     ]
    }
   ],
   "source": [
    "print('my message')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Action 1d:*** Show the help documentation for the ```max``` function instead of the ```print``` function. Based on the help, use the ```max``` function to find the highest value of two numbers: ```5``` and ```2```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function print in module builtins:\n",
      "\n",
      "print(...)\n",
      "    print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
      "    \n",
      "    Prints the values to a stream, or to sys.stdout by default.\n",
      "    Optional keyword arguments:\n",
      "    file:  a file-like object (stream); defaults to the current sys.stdout.\n",
      "    sep:   string inserted between values, default a space.\n",
      "    end:   string appended after the last value, default a newline.\n",
      "    flush: whether to forcibly flush the stream.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(print)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Variable Names\n",
    "\n",
    "There are three types of basic variables in Python. These are:\n",
    "\n",
    "* string (e.g. 'banana')\n",
    "* integer (e.g. 2)\n",
    "* float (e.g. 3.1415)\n",
    "\n",
    "A variable name must begin with a letter or underscore but not with a number or other special characters. A variable name must not have a space and lowercase or uppercase are permitted.\n",
    "\n",
    "***Action 1e:*** Correct the following errors in the variable names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-6-908eaaee6c81>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-6-908eaaee6c81>\"\u001b[1;36m, line \u001b[1;32m2\u001b[0m\n\u001b[1;33m    1var = 1\u001b[0m\n\u001b[1;37m       ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# correct the variable name errors\n",
    "1var = 1\n",
    "my Var = 2\n",
    "test!Var = 3\n",
    "#myVar = 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Variable Types\n",
    "\n",
    "Every variable is stored as an object that is shown with the ```type``` function:\n",
    "\n",
    "```python\n",
    "myVar = 2\n",
    "print(type(myVar))\n",
    "```\n",
    "\n",
    "Produces ***<class 'int'>***, meaning that ```myVar``` is an integer type. Values can be converted to a different type such as with:\n",
    "\n",
    "* ```int```: convert to an integer\n",
    "* ```float```: convert to a floating point number with a decimal value\n",
    "* ```str```: convert to a string (sequence of characters)\n",
    "\n",
    "The type of the variable can change (mutable) in Python.\n",
    "\n",
    "***Action 1f:*** Print the variable value and type for ```x```, ```y```, and ```z```. Explain why ```x``` is 46 and not 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = int('2'+'3')*2\n",
    "y = x - 10.0\n",
    "z = str(4.0)\n",
    "\n",
    "# print the values of x, y, and z\n",
    "\n",
    "# determine the type for x, y, and z\n",
    "\n",
    "# explain why x is equal to 46, not 10\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Functions\n",
    "\n",
    "In addition to a value, the ```str``` object has useful functions such as ```lower``` and ```upper``` to convert to lower or upper case, respectively.\n",
    "\n",
    "```python\n",
    "myVar = 'my name'\n",
    "print(myVar.upper())\n",
    "```\n",
    "\n",
    "The result is ```'MY NAME'```.\n",
    "\n",
    "***Action 1g:*** Insert your name and then convert and print it in lower case with the str.lower() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myStr = 'Your Name'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Operators\n",
    "\n",
    "Operators are used to transform, compare, join, substract, etc. Below is a list of operators in descending order of precedence when there are no parenthesis to guide the precedence."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Operator | Description |\n",
    "| --- | --- |\n",
    "| ** | Exponent |\n",
    "| *, /, //, % | Multiplication, Division, Floor division, Modulus |\n",
    "| +, - | Addition, Subtraction |\n",
    "| <= < > >= | Comparison |\n",
    "| = %= /= //= -= += *= **= | Assignment |\n",
    "| is, is not | Identity |\n",
    "| in, not in | Membership |\n",
    "| not, or, and | Logical |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Action 1h:*** Use the operator list to determine whether $5^5$ is greater than $2^{10}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# modify to determine whether 5^5 is greater than 2^10\n",
    "5 == 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem #2\n",
    "\n",
    "The rate of heat transfer ($q$) from a heated flat plate with a cool fluid stream flowing across it can be found by:\n",
    "\n",
    "$q = h \\Delta T = h \\left(T_{plate}-T_{water} \\right)$\n",
    "\n",
    "where $h$ is the heat transfer coefficient and $\\Delta T$ is the change in temperature between the cool fluid and the plate.  The heat transfer coefficient is related to $Nu$, the dimensionless Nusselt number as:\n",
    "\n",
    "$Nu = \\frac{hL}{k} = 0.332 Pr^{1/3} Re^{1/2}$\n",
    " \n",
    "where $L$ is the plate length, $k$ is the fluid thermal conductivity, $Pr$ is the dimensionless Prandtl number and $Re$ is the dimensionless Reynolds number.  \n",
    "The last two quantities are calculated according to $Re = \\frac{\\rho L v}{\\mu}$ and $Pr = \\frac{\\mu c_p}{k}$ where $\\mu$ is the fluid viscosity, $c_p$ is the fluid heat capacity, $v$ is the fluid velocity, and $\\rho$ is the density of the fluid. \n",
    "\n",
    "What is the heat transfer rate, in $W/m^2$, from a flat plate 2 $m$ long and at a temperature of 343 $K$, if a stream of water passes over it at a velocity of 1.45 $m/s$? The temperature of the water is 294 $K$. The water properties are $\\mu = 9.79x10^{-4}$ $Pa\\,s$, $\\rho = 998 \\, kg/m^3$, $k = 0.601 \\, W/(m \\, K)$, and $c_p = 4.18x10^3 \\, J/(kg\\,K)$. Begin by giving all the known quantities names, then calculate $Nu$. The heat transfer coefficient $h$ can be obtained once $Nu$ is known.\n",
    "\n",
    "Your solution should be 15931.12 $\\frac{W}{m^2}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# constants\n",
    "L      = 2       # m\n",
    "Tplate = 343     # K\n",
    "v      = 1.45    # m/s\n",
    "Twater = 294     # K\n",
    "mu     = # fill-in # Pa*s\n",
    "rho    = 998     # kg/m^3\n",
    "k      = # fill-in # W/m-K\n",
    "cp     = 4.18e3  # J/kg-K\n",
    "\n",
    "# derived quantities\n",
    "Re = # fill-in\n",
    "Pr = # fill-in\n",
    "Nu = # fill-in\n",
    "h  = # fill-in\n",
    "q  = # fill-in\n",
    "\n",
    "print('Rate of Heat Transfer')\n",
    "print(str(round(q,2))+' W/m^2') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem #3\n",
    "\n",
    "#### Packages\n",
    "\n",
    "Python capabilities are extended with many useful packages. A few of the packages that we'll use in this class are:\n",
    "\n",
    "* <a href='https://www.numpy.org' target='_blank'>NumPy (Numerical Python)</a> as a base numerical package\n",
    "* <a href='https://matplotlib.org' target='_blank'>Matplotlib</a> for creating charts and visualizing data\n",
    "* <a href='https://www.scipy.org' target='_blank'>SciPy (Scientific Python)</a> as a base scientific package\n",
    "* <a href='https://pandas.pydata.org' target='_blank'>Pandas</a> data analysis library\n",
    "* <a href='https://gekko.readthedocs.io/en/latest/' target='_blank'>Gekko</a> for simulation and optimization\n",
    "* <a href='https://pypi.org/project/tclab/' target='_blank'>TCLab</a> package for operating the Temperature Control Lab\n",
    "\n",
    "Anaconda comes with many of the packages built-in but there are sometimes packages that you'll need to add. Below is a video tutorial on managing the packages in Python. For the tank problem below, you'll need to use the NumPy and Matplotlib packages. Skip the package installation if you are using Anaconda or Google Colab."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/Z_Kxg-EYvxM\"              frameborder=\"0\" allow=\"autoplay; encrypted-media\" allowfullscreen></iframe>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "video('Z_Kxg-EYvxM')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can import a package with ```import **package** as **pk**``` where ```**package**``` is the package name and ```**pk**``` is the abbreviated name.\n",
    "\n",
    "***Action 3a:*** Import the ```numpy``` package as ```np``` (shortened name) and get help on the ```np.linspace``` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Action 3b:*** Use ```np.linspace``` to define 20 equally spaced values between $0$ and $2\\,\\pi$. Name the variable ```x``` and use the built-in ```np.pi``` constant for $\\pi$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Action 3c:*** Use ```np.sin``` to calculate a new variable ```y``` as $y=2\\,\\sin{\\left(\\frac{x}{2}\\right)}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Action 3d:*** Import the ```matplotlib.pyplot``` package as ```plt``` (shortened name) and show the help on the ```plt.plot``` function. To show plots in an IPython notebook, the additional code ```%matplotlib inline``` is required."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Action 3e:*** Create a plot of ```x``` and ```y``` with the ```plt.plot``` function. Add an x-label with ```plt.xlabel``` and a y-label with ```plt.ylabel```. If you are not using an IPython notebook, include ```plt.show()``` to display the plot. You can also include it in an IPython notebook but it won't have any effect."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tank Pressure Limits\n",
    "\n",
    "Your team is tasked with designing the operational protocol for a batch reactor (basically a tank) for a particular reaction that must be carried out in the absence of oxygen to reduce the formation of byproducts.  You have an idea to first fill the tank with nitrogen and then add the liquid mixture.  As the liquid mixture is added, part of the nitrogen gas will be removed to prevent pressure buildup.  \n",
    "\n",
    "To flush the oxygen out, the tank will initially be filled so that the nitrogen is at 298.15 K and 1.25 atm.  To keep oxygen out, you want to make sure that the pressure inside the tank remains greater than 1.0 atm after the liquid is added; however, the pressure should not become greater than 2.5 atm in order to keep the cost of the tank to a minimum.  The tank has a capacity of 4000 L, and depending upon the amount of product needed, the volume of liquid in the tank can range from 3000 to 3500 L.  In all cases, 25% of the nitrogen initially placed in the container remains after the tank is filled with the liquid.  Given these constraints determine the range of possible operating conditions (temperatures, volumes, and pressures) so that appropriate heat transfer and control equipment can be designed.  \n",
    "\n",
    "Suggestions:  \n",
    "* You may assume nitrogen and the liquid mixture are at the same temperature and pressure.\n",
    "* You may assume that nitrogen is an ideal gas described by the equation $P\\,V = n\\,R_g\\,T$.\n",
    "* One of the first things you need to do is calculate the amount of nitrogen that is placed into the empty tank.  I would also suggest setting up the spreadsheet with a column of possible temperatures and a row of possible volumes.\n",
    "* You may assume that changes in the volume of liquid due to changes in temperature and pressure is negligible and the volatility of the liquid is low such that nitrogen is essentially the only component of the gas phase.\n",
    "* Remember that the number of moles, temperature, pressure, and volume of the gas are related by the ideal gas law.  You can only set three of the four variables independently.\n",
    "* The hardest part of this problem is figuring out what is needed.  Remember, you are the engineer trying to present some data that can be used for future design.\n",
    "\n",
    "***Step 1:*** Calculate the initial moles of $N_2$ that are needed when the tank is first filled. Use the ideal gas law $\\left( P\\,V = n\\,R_g\\,T \\right)$ to determine the number of moles of nitrogen at 1.25 atm in an otherwise empty tank."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "T = 298.15  # K\n",
    "P = 1.25    # atm\n",
    "V = 4000    # L\n",
    "Rg = 0.0821 # L*atm/mol/K\n",
    "n_N2 = #fill-in   # moles of N2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Step 2:*** Calculate the number of moles when the liquid is introduced and there is only 25% of the volume that remains for the nitrogen at 1.25 atm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_N2 = #fill-in  # moles with 25% remaining"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Step 3:*** Use NumPy ```np.linspace``` to create 20 linearly spaced values. The volume should be between 500 and 1000 L and the temperature should be between 100 and 600 K."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "V = np.linspace(#fill-in)\n",
    "T = np.linspace(#fill-in)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Step 4:*** Use NumPy ```np.meshgrid``` to create a 20x20 meshgrid to calculate all of the potential combinations of volume and temperature. This code does not need to be modified."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create meshgrid\n",
    "Vm,Tm = np.meshgrid(V,T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Step 5:*** Calculate the pressures at each of the 400 (20x20) combinations of volume and temperature. This can be done with one line of code, using ```Vm```, ```Tm```, ```Rg```, and ```n_N2```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# calculate pressure\n",
    "Pm = #fill-in"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Step 6:*** Create a contour plot of the pressure with changes in temperature and volume. Most of the code is provided below but you should add the x-label and y-label values to show which one is temperature and which one is volume."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# plot results\n",
    "plt.figure()\n",
    "plt.contourf(Vm,Tm,Pm)\n",
    "plt.colorbar()\n",
    "CS2 = plt.contour(Vm,Tm,Pm,[1.0,2.5],colors=['orange','red'])\n",
    "plt.clabel(CS2, inline=1, fontsize=10)\n",
    "plt.xlabel(#fill-in)\n",
    "plt.ylabel(#fill-in)\n",
    "plt.show() "
   ]
  }
 ],
 "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}