05 - Units Quantities - instructor-with answer.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Units and Quantities\n",
    "\n",
    "## Objectives\n",
    "\n",
    "- Use units\n",
    "- Create functions that accept quantities as arguments\n",
    "- Create new units"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the most common problems in physics and the development of models are related to the conversion and management of physical units. \n",
    "\n",
    "This problem explains the crash of the Mars Climate Orbiter probe on the planet Mars. \n",
    "See https://en.wikipedia.org/wiki/Mars_Climate_Orbiter\n",
    "\n",
    "In this episode, we will use *one* of the available libraries which can help you to avoid the same problem in your development.\n",
    "\n",
    "We are going to learn at the same time, how to install a new library [astropy](http://docs.astropy.org/en/stable/index.html) which will give access to the [unit module](http://docs.astropy.org/en/stable/units/index.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Installing a new python library"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now install the *astropy* library using the same method as we did for pyfits:\n",
    "\n",
    "```bash\n",
    "pip install astropy --user\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After having successfully installed the astropy library, we can import the units modules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep": true
   },
   "outputs": [],
   "source": [
    "from astropy import units as u\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basics\n",
    "\n",
    "How do we define a Quantity and which parts does it have?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a quantity length\n",
    "length = 26.2 * u.meter\n",
    "# print it\n",
    "print(length) # length is a quantityq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Type of quantity\n",
    "type(length)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Type of unit\n",
    "type(u.meter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Quantity\n",
    "length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# value\n",
    "length.value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# unit\n",
    "length.unit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# information\n",
    "length.info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quantities can be converted to other units systems or factors by using the function: **to()**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert it to: km, lyr\n",
    "length.to(u.km)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "length.to(u.lightyear)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can do arithmetic operations when quantities have the compatible units:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# arithmetic with distances\n",
    "distance_start = 10 * u.mm\n",
    "distance_end = 23 * u.km\n",
    "length = distance_end - distance_start\n",
    "print(length)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quantities can also be combined, for example to measure speed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# calculate a speed\n",
    "time = 15 * u.minute\n",
    "speed = length / time\n",
    "speed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can ask the units library what the *irreducible* unit of a quantity is. \n",
    "Irreducible in the sense of the basic unit in the unit system of your choice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# decompose it\n",
    "speed.decompose()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can ask for the result in a specific system by using certain methods. Here to have the value of the quantity *speed* in the SI system and in the CGS system."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "speed.si"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "speed.cgs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Warning**\n",
    "\n",
    "There are no methods for the imperial system and so the unit needs to be converted. In addition the 'imperial' library for achieving this is not imported by default, so another import is required.\n",
    "This system exists for historical reasons (only three countries in the world are still using it as their official system). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style='background:#B1E0A8; padding:10px 10px 10px 10px;'>\n",
    "<H2> Challenges </H2>\n",
    "\n",
    " <ol>\n",
    " <li> Convert the speed to imperial units (miles/hour) using: <br>\n",
    "\n",
    " ```from astropy.units import imperial```\n",
    " </li>\n",
    " <li> Calculate whether a pint is more than half litre<br>\n",
    " \n",
    " <emph>Can compare quantities as comparing variables?</emph> <br>\n",
    " \n",
    " <p>Something strange? Check what definition of <a href='https://en.wikipedia.org/wiki/Pint'>pint</a> astropy is using.</p>\n",
    " </li>\n",
    " <li> Do units work with areas? Calculate the area of a rectangle 3 km by 5 m. Show them in $m^2$ (hint: irreducible)  and convert them to $yards^2$</li>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer challenge 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from astropy.units import imperial\n",
    "speed.to(imperial.mile/u.hour)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer challenge 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "imperial.pint > 0.5 * u.l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The pint used in that library is the *US* pint which is 474 ml when the *UK* pint is 568 ml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer challenge 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rectangle_area = 3 * u.km * 5 * u.m\n",
    "print(rectangle_area)\n",
    "print(rectangle_area.decompose())\n",
    "print(rectangle_area.to(imperial.yard ** 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rectangle_area"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The answer is correct but dot not give the proper unit. We should have $m^2$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rectangle_area.decompose()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rectangle_area = rectangle_area.decompose()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rectangle_area"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Composed units\n",
    "\n",
    "Many units are compositions of others. One could create new combinationes for ease of use, for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a composite unit centimeter per second\n",
    "cms = u.cm / u.s\n",
    "speed.to(cms)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# and in the imperial system\n",
    "mph = imperial.mile / u.hour\n",
    "speed.to(mph)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and others are already a composition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# what can be converted from s-1?\n",
    "(u.s ** -1).compose()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# or Jules?\n",
    "(u.joule).compose()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometime we get *no units* quantitites"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# no units\n",
    "nounits = 20. * u.cm / (1. * u.m)\n",
    "nounits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happen if we add a number to this?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# arithmetic with no units\n",
    "nounits + 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# final value of a no unit quantity\n",
    "nounits.decompose() # It's a unitless quantity\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style='background:#B1E0A8; padding:10px 10px 10px 10px;'>\n",
    "<H2> Challenges </H2>\n",
    "\n",
    " <ol>\n",
    " <li> Create the 'uk_pint' composite unit.\n",
    " </li>\n",
    " Hint: Pint(UK) = 0.568261485 litre\n",
    " <li>Convert the value of the US imperial pint to the UK imperial pint.\n",
    " </li>\n",
    " </div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "uk_pint = 0.568261485 * u.l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "imperial.pint.to(uk_pint)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Equivalencies\n",
    "\n",
    "Some conversions are not done by a conversion factor as between miles and kilometers, for example converting between wavelength and frequency."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# converting spectral quantities\n",
    "(656.281 * u.nm).to(u.Hz) # Fails because they are not compatible"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Equivalent unit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are some unit conversions that would initially appear to be unconvertible. \n",
    "For example, it is possible to convert meters into Hertz. At first glance it seems to be wrong but if you know the quantities for wavelength and frequencies, it is indeed a valid conversion:\n",
    "\n",
    "$\\lambda = \\frac{c}{\\nu}$\n",
    "\n",
    "Where:\n",
    "\n",
    "\n",
    "- $lambda \\sim m$ \n",
    "- $c \\sim \\frac{m}{s}$\n",
    "- $\\nu \\sim Hz \\sim s^{-1}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(656.281 * u.nm).to(u.Hz)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "but doing it right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(656.281 * u.nm).to(u.Hz, equivalencies=u.spectral())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "u.spectral?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Other built-in equivalencies are: \n",
    " - Doppler (`dopplr_radio`, `doppler_optical`, `doppler_relativistic`)\n",
    " - spectral flux density\n",
    " - temperature\n",
    " - brigthness temperature\n",
    " - temperature energy\n",
    " - and you can [build your own](http://astropy.readthedocs.org/en/stable/units/equivalencies.html#writing-new-equivalencies)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Finding the equivalencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "u.Hz.find_equivalent_units()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... and we can also include other systems"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "u.Hz.find_equivalent_units(equivalencies=u.spectral())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arrays\n",
    "\n",
    "Quantities can also be applied to arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# different ways of defining a quantity for a single value\n",
    "length = 44 * u.m\n",
    "time = u.Quantity(23, u.s)\n",
    "speed = length / time\n",
    "speed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# now with lists\n",
    "length_list = [1, 2, 3] * u.m\n",
    "\n",
    "# and arrays\n",
    "import numpy as np\n",
    "time_array = np.array([1, 2, 3]) * u.s\n",
    "\n",
    "# and its arithmetics\n",
    "length_list / time_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# angles are smart!\n",
    "#angle = u.Quantity(np.arange(180), u.deg)\n",
    "\n",
    "angle = np.arange(180) * u.deg\n",
    "\n",
    "print(angle[[0, -1]])\n",
    "print(np.sin(angle[[0, -1]]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting quantities\n",
    "\n",
    "To work nicely with matplotlib we need to do the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "keep": true
   },
   "outputs": [],
   "source": [
    "# allowing for plotting\n",
    "from astropy.visualization import quantity_support\n",
    "quantity_support()\n",
    "\n",
    "# loading matplotlib\n",
    "%matplotlib inline\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "# Ploting the previous array\n",
    "plt.plot(angle, np.sin(angle))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Temperature\n",
    "\n",
    "Temperature have a peculiar behaviour and it not possible to add them without asking to convert to a common unit.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t1 = 0 * u.deg_C\n",
    "t2 = 22 * u.K\n",
    "t3 = 32 * imperial.Fahrenheit\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t1 + t2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t1 + t3.to(u.deg_C, equivalencies=u.temperature())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t1.to(u.K, equivalencies=u.temperature()) + t2"
   ]
  }
 ],
 "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}