solution_chapter5.ipynb

{
 "cells": [
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\\rhead{Chapter 5}\n",
    "\\begin{shortexercises}\n",
    "% SHORT EXERCISE 1\n",
    "\\begin{exercise}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\textbf{(10 points)}$ Write a python dictionary that contains the key:value pairs that are have for a key name of the common subatomic particles (i.e., proton, neutron, and electron) and the value of the mass of the particle in kilograms."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\\solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'electron': 9.10938291e-31, 'neutron': 1.674927351e-27, 'proton': 1.67262178e-27}\n"
     ]
    }
   ],
   "source": [
    "# Chapter 5 SE 1\n",
    "# NUEN 329\n",
    "\n",
    "masses = {\"proton\":1.67262178E-27,\n",
    "          \"neutron\":1.674927351E-27,\n",
    "          \"electron\":9.10938291E-31}\n",
    "\n",
    "print(masses)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\\vspace{0.5cm}\n",
    "\\begin{center}\n",
    "\\begin{tabular}{|c|l|}\n",
    "    \\hline\n",
    "    \\multicolumn{2}{|c|}{\\textbf{Point Breakdown}} \\\\\n",
    "    \\hline\n",
    "    3 pts & Attempt points: list created \\\\\n",
    "    \\hline\n",
    "    4 pts & Creates proper list and prints \\\\\n",
    "    \\hline\n",
    "    3 pts & Report formatted well and additional comments made \\\\\n",
    "    \\hline\n",
    "\\end{tabular}\n",
    "\\end{center}"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\\end{exercise}\n",
    "% SHORT EXERCISE 2\n",
    "\\begin{exercise}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\textbf{(10 points)}$ Using the midpoint_rule function defined above, compute the integral of $\\mathrm{sin}^2x$, over the range $[0,2\\pi]$. This could be a good time to use a lambda function."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\\solution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is known that"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\int_0^{2\\pi} \\mathrm{sin}^2(x) = \\pi.$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By using the $\\tt{midpoint\\_rule}$ function defined in chapter 5, we should then expect to come up with an answer of roughly $\\pi$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The estimate is 3.14159265359\n",
      "3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "# Chapter 5 SE 2\n",
    "# NUEN 329\n",
    "\n",
    "import numpy as np\n",
    "   \n",
    "def midpoint_rule(f,a,b,num_intervals):\n",
    "    \"\"\"integrate function f using the midpoint rule\n",
    "    \n",
    "    Args:\n",
    "        f: function to be integrated, it must take one argument\n",
    "        a: lower bound of integral range\n",
    "        b: upper bound of integral range\n",
    "        num_intervals: the number of intervals to break [a,b] into\n",
    "    Returns:\n",
    "        estimate of the integral\n",
    "    \"\"\"\n",
    "    \n",
    "    L = (b-a) #how big is the range\n",
    "    dx = L/num_intervals #how big is each interval\n",
    "    #midpoints are a+dx/2, a+3dx/2, ..., b-dx/2\n",
    "    midpoints = np.arange(num_intervals)*dx+0.5*dx+a\n",
    "    integral = 0\n",
    "    for point in midpoints:\n",
    "        integral = integral + f(point)\n",
    "    return integral*dx\n",
    "\n",
    "# Define sin^2(x) using a lambda function\n",
    "y = lambda x: np.sin(x)*np.sin(x)\n",
    "\n",
    "# Evaluate using midpoint_rule with 100 intervals\n",
    "estimate = midpoint_rule(y,0,2*np.pi,100)\n",
    "print(\"The estimate is\",estimate)\n",
    "\n",
    "print(np.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculated with 100 intervals, the answer is spot on out past 10 decimal points. Even with only 3 intervals, our answer agreement is still excellent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The estimate is 3.14159265359\n"
     ]
    }
   ],
   "source": [
    "# Evaluate using midpoint_rule with 3 intervals\n",
    "estimate = midpoint_rule(y,0,2*np.pi,3)\n",
    "print(\"The estimate is\",estimate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Anything less than 3, however, and there is a poor agreement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The estimate is 6.28318530718\n"
     ]
    }
   ],
   "source": [
    "# Evaluate using midpoint_rule with 2 intervals\n",
    "estimate = midpoint_rule(y,0,2*np.pi,2)\n",
    "print(\"The estimate is\",estimate)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\\vspace{0.5cm}\n",
    "\\begin{center}\n",
    "\\begin{tabular}{|c|l|}\n",
    "    \\hline\n",
    "    \\multicolumn{2}{|c|}{\\textbf{Point Breakdown}} \\\\\n",
    "    \\hline\n",
    "    3 pts & Attempt points: function created to represent $\\mathrm{sin}^2(x)$ \\\\\n",
    "    \\hline\n",
    "    4 pts & Uses midpoint\\_rule and prints reasonable solution \\\\\n",
    "    \\hline\n",
    "    3 pts & Report formatted well and additional comments made \\\\\n",
    "    \\hline\n",
    "\\end{tabular}\n",
    "\\end{center}"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\\end{exercise}\n",
    "\\end{shortexercises}"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\\begin{problem}{Problem 1: Plutonium Decay Chain}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\textbf{(100 points)}$ Consider the plutonium decay chain shown below. Construct a dictionary where the keys are $\\texttt{A-X}$ where $\\texttt{A}$ is the mass number of the nuclide and $\\texttt{X}$ is the atomic symbol for the nuclide. For example one key is $\\texttt{239-Pu}$. The value for the aforementioned keys should be a dictionary with key:value pairs:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\\begin{enumerate}\n",
    "\t\\item key: \\texttt{half-life}, value: the half-life of the decay in seconds,\n",
    "\t\\item key: \\texttt{decay\\_mode}, value: the decay mode (i.e., alpha, beta, or stable in this case), and\n",
    "    \\item key: \\texttt{mass}, value: the mass of the nuclide.\n",
    "\\end{enumerate}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Your code should use the dictionary to print out "
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\\begin{enumerate}\n",
    "\t\\item All the nuclides that decay by alpha decay\n",
    "\t\\item The activity of 1 kilogram of each nuclide that is a beta emitter\n",
    "\\end{enumerate}"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\\solution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\tt{For}$ loops are employed that go through each nuclide and check whether the decay mode is $\\tt{alpha}$ or $\\tt{beta}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the beta decay case, the decay constant is first determined as"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\lambda = \\frac{\\mathrm{ln}(2)}{t_{1/2}},$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the number density then calculated as"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$N = \\frac{1000\\text{ kg} \\times N_\\mathrm{A}}{M},$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and lastly the activity determined by"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$A = \\lambda N.$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the definition of the half-life of each element, the pre-defined constants $\\texttt{aToSec}$, $\\texttt{dToSec}$, $\\texttt{hToSec}$ and $\\texttt{mToSec}$ are employed to simplify the conversions of all half-lifes to units of seconds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The alpha emitters in the Pu decay chain are:\n",
      "211-Bi\n",
      "219-Rn\n",
      "231-Pa\n",
      "215-Po\n",
      "227-Th\n",
      "239-Pu\n",
      "233-Ra\n",
      "235-U\n",
      "The activity of 1kg of each beta emitter is:\n",
      "227-Ac - 2.67770e+15 Bq ( 7.23782e+04 Ci )\n",
      "211-Pb - 9.13373e+20 Bq ( 2.46885e+10 Ci )\n",
      "231-Th - 1.96654e+19 Bq ( 5.31556e+08 Ci )\n",
      "207-Tl - 7.04652e+21 Bq ( 1.90467e+11 Ci )\n",
      "7.0465168531e+21\n"
     ]
    }
   ],
   "source": [
    "# Chapter 5 Problem 1\n",
    "# NUEN 329\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "# Useful constants\n",
    "aToSec = 365*24*60*60 # yrs to sec\n",
    "dToSec = 24*60*60 # days to sec\n",
    "hToSec = 60*60 # hrs to sec\n",
    "mToSec = 60 # min to sec\n",
    "N_A = 6.022E23 # Avogadro's number\n",
    "\n",
    "# Define the dictionary\n",
    "chain = {\"239-Pu\":{\"half-life\":24110*aToSec,\n",
    "                   \"decay_mode\":\"alpha\",\n",
    "                   \"mass\":239.052},\n",
    "         \"235-U\":{\"half-life\":7.038E8*aToSec,\n",
    "                  \"decay_mode\":\"alpha\",\n",
    "                  \"mass\":235.044},\n",
    "         \"231-Th\":{\"half-life\":25.52*hToSec,\n",
    "                   \"decay_mode\":\"beta\",\n",
    "                   \"mass\":231.036},\n",
    "         \"231-Pa\":{\"half-life\":32760*aToSec,\n",
    "                   \"decay_mode\":\"alpha\",\n",
    "                   \"mass\":231.036},\n",
    "         \"227-Ac\":{\"half-life\":21.773*aToSec,\n",
    "                   \"decay_mode\":\"beta\",\n",
    "                   \"mass\":227.028},\n",
    "         \"227-Th\":{\"half-life\":18.72*dToSec,\n",
    "                   \"decay_mode\":\"alpha\",\n",
    "                   \"mass\":227.028},\n",
    "         \"233-Ra\":{\"half-life\":11.435*dToSec,\n",
    "                   \"decay_mode\":\"alpha\",\n",
    "                   \"mass\":233.047},\n",
    "         \"219-Rn\":{\"half-life\":3.96,\n",
    "                   \"decay_mode\":\"alpha\",\n",
    "                   \"mass\":219.009},\n",
    "         \"215-Po\":{\"half-life\":1.781E-3,\n",
    "                   \"decay_mode\":\"alpha\",\n",
    "                   \"mass\":214.999},\n",
    "         \"211-Pb\":{\"half-life\":36.1*mToSec,\n",
    "                   \"decay_mode\":\"beta\",\n",
    "                   \"mass\":210.989},\n",
    "         \"211-Bi\":{\"half-life\":2.14*mToSec,\n",
    "                   \"decay_mode\":\"alpha\",\n",
    "                   \"mass\":210.987},\n",
    "         \"207-Tl\":{\"half-life\":4.77*mToSec,\n",
    "                   \"decay_mode\":\"beta\",\n",
    "                   \"mass\":206.977},\n",
    "         \"207-Pb\":{\"half-life\":0,\n",
    "                   \"decay_mode\":\"stable\",\n",
    "                   \"mass\":206.976}}\n",
    "\n",
    "# Print nuclides that alpha decay\n",
    "print(\"The alpha emitters in the Pu decay chain are:\")\n",
    "for nuclide in chain:\n",
    "    # Only alpha emitters\n",
    "    if(chain[nuclide][\"decay_mode\"] == \"alpha\"):\n",
    "        print(nuclide)\n",
    "        \n",
    "# Print the activities of 1kg of the beta emitters\n",
    "print(\"The activity of 1kg of each beta emitter is:\")\n",
    "for nuclide in chain:\n",
    "    # Only beta emitters\n",
    "    if(chain[nuclide][\"decay_mode\"] == \"beta\"):\n",
    "        # Determine decay constant\n",
    "        lam = np.log(2)/chain[nuclide][\"half-life\"]\n",
    "        # Determine number of particles in 1 kg\n",
    "        N = 1000*N_A/chain[nuclide][\"mass\"]\n",
    "        # Determine activity\n",
    "        A = lam*N\n",
    "        # Convert to Ci (not required)\n",
    "        ACi = A*2.703E-11\n",
    "        print(nuclide,\"-\",\"%.5e\" % A,\"Bq (\",\"%.5e\" % ACi,\"Ci )\")\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\\vspace{0.5cm}\n",
    "\\begin{center}\n",
    "\\begin{tabular}{|c|l|}\n",
    "    \\hline\n",
    "    \\multicolumn{2}{|c|}{\\textbf{Point Breakdown}} \\\\\n",
    "    \\hline\n",
    "    15 pts & Attempt points: structure of a dictionary present \\\\\n",
    "    \\hline\n",
    "    10 pts & Attempt points: for loops to print alphas and betas present \\\\\n",
    "    \\hline\n",
    "    15 pts & Correct alpha emitters printed \\\\\n",
    "    \\hline\n",
    "    7 pts & Correct beta emitters printed \\\\\n",
    "    \\hline\n",
    "    8 pts & Correct beta emitter activities printed (any units) \\\\\n",
    "    \\hline\n",
    "    15 pts & Explanation of process used in code \\\\\n",
    "    \\hline \n",
    "    15 pts & Code well commented and exercises brevity \\\\\n",
    "    \\hline\n",
    "    15 pts & Report format \\\\\n",
    "    \\hline\n",
    "\\end{tabular}\n",
    "\\end{center}"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\\end{problem}\n",
    "% PROBLEM 2\n",
    "\\begin{problem}{Problem 2: Simple Cryptographic Cipher}"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\\texttt{\\{cipherDict = {\"a\":\"n\",\"b\":\"o\",...,\"m\":\"z\",\"n\":\"a\",...}\\}}\n",
    "\\br\\br"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\textbf{(100 points)}$ To transmit a message you desire to encrypt it. In the terminology of cryptography the original message is the plain text and the encrypted message is called the cipher text. The means of encrypting the message is called a cipher. A simple is the ROT-13 cipher, which is an example of the Caesar cipher. In this cipher the letter is replaced by a letter 13 places away in the alphabet. This can be encoded easily in a dictionary:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function called $\\texttt{cipher}$ that takes in a string and returns an encrypted cipher text using the ROT-13 cipher. Your\n",
    "code must do the following:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\\begin{enumerate}\n",
    "\t\\item Handle lower case and capital letters,\n",
    "\t\\item Not do anything to characters that are not alphabet characters, e.g. numbers, punctuation, and other characters, and,\n",
    "\t\\item Only take a single parameter as an argument to the function. This argument will be a string containing the plain text.\n",
    "\\end{enumerate}"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\\solution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A $\\texttt{for}$ loop is used to loop through each character of the inputted string. The python class $\\texttt{isupper}$ is used to determine if the character being encrypted is upper case, and the python class $\\texttt{islower}$ is used to determine if the character is lower case. If it is lower case, the dictionary compliment is appended. If it is upper case, the letter is convereted to lowercase, and then the uppercase of the dictionary compliment is appended. If it is not alphabetical, then the character is passed right to the enctypted variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using ROT-13 cipher on the string: The 12th Man!\n",
      "Result: Gur 12gu Zna!\n"
     ]
    }
   ],
   "source": [
    "# Chapter 5 Problem 2\n",
    "# NUEN 329\n",
    "\n",
    "def cipher(string):\n",
    "    \"\"\"Encrypts a given string using the ROT-13 cipher\n",
    "    \n",
    "    Args:\n",
    "        string: string to be encrypted\n",
    "    Returns:\n",
    "        encrypted: the encrypted string\n",
    "    \"\"\"\n",
    "    \n",
    "    # Define cipher dictionary\n",
    "    cipherDict = {\"a\":\"n\",\"b\":\"o\",\"c\":\"p\",\"d\":\"q\",\"e\":\"r\",\n",
    "              \"f\":\"s\",\"g\":\"t\",\"h\":\"u\",\"i\":\"v\",\"j\":\"w\",\n",
    "              \"k\":\"x\",\"l\":\"y\",\"m\":\"z\",\"n\":\"a\",\"o\":\"b\",\n",
    "              \"p\":\"c\",\"q\":\"d\",\"r\":\"e\",\"s\":\"f\",\"t\":\"g\",\n",
    "              \"u\":\"h\",\"v\":\"i\",\"w\":\"j\",\"x\":\"k\",\"y\":\"l\",\n",
    "              \"z\":\"m\"}\n",
    "    \n",
    "    # Create empty string for encrypted message\n",
    "    encrypted = \"\"\n",
    "    \n",
    "    # Loop through each character in the input\n",
    "    for i in range(len(string)):\n",
    "        # Character is uppercase\n",
    "        if(string[i].isupper()):\n",
    "            encrypted += cipherDict[string[i].lower()].capitalize()\n",
    "        # Character is lowercase\n",
    "        elif(string[i].islower()):\n",
    "            encrypted += cipherDict[string[i]]\n",
    "        # Character is not alphabetical\n",
    "        else:\n",
    "            encrypted += string[i]\n",
    "            \n",
    "    return encrypted\n",
    "\n",
    "# Test it out\n",
    "toCipher = \"The 12th Man!\"\n",
    "encrypted = cipher(toCipher)\n",
    "print('Using ROT-13 cipher on the string:',toCipher)\n",
    "print('Result:',encrypted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As seen, the alphabetical terms were encrypted and the non-alphabetical terms passed through."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\\vspace{0.5cm}\n",
    "\\begin{center}\n",
    "\\begin{tabular}{|c|l|}\n",
    "    \\hline\n",
    "    \\multicolumn{2}{|c|}{\\textbf{Point Breakdown}} \\\\\n",
    "    \\hline\n",
    "    10 pts & Attempt points: $\\tt{cipherDict}$ dictionary structure \\\\\n",
    "    \\hline\n",
    "    10 pts & Attempt points: $\\tt{for}$ loop to loop through each character (or other method) \\\\\n",
    "    \\hline\n",
    "    20 pts & Correctly inputs student supplied string \\\\\n",
    "    \\hline\n",
    "    5 pts & Code ignores non-alphabetical characters \\\\\n",
    "    \\hline\n",
    "    10 pts & Uses a function named $\\tt{cipher}$ to do the above actions \\\\\n",
    "    \\hline\n",
    "    15 pts & Explanation of process used in code \\\\\n",
    "    \\hline \n",
    "    15 pts & Code well commented and exercises brevity \\\\\n",
    "    \\hline\n",
    "    15 pts & Report format \\\\\n",
    "    \\hline\n",
    "\\end{tabular}\n",
    "\\end{center}"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\\end{problem}"
   ]
  }
 ],
 "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.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}