Reports/Exercise4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 4\n",
    "\n",
    "## Abstract\n",
    "\n",
    "Although it has been the ultimate goal for scientists to find the analytical solution of the nature, some complicated sysyems still hinder people from this dream in which circumstances numerical methods are necessary. Ordinary differential equations are good practice for us to get familiar with the numerical methods, for we can compare our result with the known analytical solution. In this problem, we consider a system in which The errors for ingoring high rank differentiation may sometimes make such methods invalid, so various initial conditions and parameters are discussed to examine the sensitivity of the parameters and the rubustness of the method.\n",
    "\n",
    "## Background\n",
    "\n",
    "### Ordinary Differential Equation \\[1\\]\n",
    "\n",
    "The categories of equations are based on the type of known quantities and the calculation on the unknown quantities. The equations are called algebraic equtions or transcedent equations if the unknown quantities are numbers. An equation is called a function equation if the unknown quantity is a function. It is called a differential equation if there are derivative or differential in an equation, among which the ones containing functions with only one variables are called the ordinary differential equations.\n",
    "\n",
    "And as is proven, the theorem about the existence and uniqueness of the solution says for a differential equation $\\frac{dy}{dx}=f(x,y)$\n",
    "with the boundary condition $y(x_0)=y_0$, the solution exists and is unique if in the region \n",
    "$$R:x_0 -a \\leq x \\leq x_0 + a,\\ y_0 -b \\leq y \\leq y_0+b $$\n",
    "(1) f(x,y) is continuous.<br>\n",
    "(2) f(x,y) satisfies the Lipschitz condition about y, which means for any pair of points $(x,y)$ and $(x,\\bar y)$, there exists N such that \n",
    "$$|f(x,y)-f(x, \\bar y)| \\leq N |y-\\bar y|$$\n",
    "This theorem provides us with confidence about the solution we find. Once it satisfys the differential conditions of thq equation, it much be the correct and the only correct solution.\n",
    "\n",
    "### Euler Methods\n",
    "\n",
    "As we know, any real or complex function that can be differentiated to infinite orders at point $x_0$ can be represented as an infinite sum of about the differentials like\n",
    "$$f(x)=\\sum_{n=0}^\\infty \\frac{f^{(n)}(x_0)}{n!}(x-x_0)^n=x_0+f'(x_0)(x-x_0)+\\frac{1}{2}f''(x_0)(x-x_0)^2+...$$\n",
    "This theorem has provided us with a way to approximate a function in forms of a poynomial function, which can be easily calculated in computers. \\[2\\]\\[3\\]Especially, if we ignore the differentials greater than the  second order, which means\n",
    "$$f(x) \\approx f(x_0)+\\frac{df(x_0)}{dx}(x-x_0)$$\n",
    "This method to figure out the approximate solution is called the Euler method.   \n",
    "Suppose the function $f(x,y)$ is  continuous and bounded in the region $a \\leq b, |y| <\\infty$,then $f(x,y)$ determines a direction field. To get the approximate solution of the ordinary equation with boundary condition \n",
    "$$\n",
    "\\begin{array}{ll} \\frac{dy}{dx}=f(x,y) \\\\ y(x_0)=y_0 \\end{array} \n",
    "$$\n",
    "divide the interval $[x_0,b]$ into n equal pieces,and the dividing points are \n",
    "$$x_k=x_0+kh,\\ \\ k=0,1,...,n$$\n",
    "$$h-\\frac{b-x_0}{n},\\ \\ x_n=b$$\n",
    "Because the tangent of the solution at the point $(x_0,y_0)$ should be f(x_0,y_0), we use the straight line passing (x_0,y_0) with the tangent f(x_0,y_0) as an approximaiton of the curve. The function of the straight line is\n",
    "$$y=y_0+f(x_0,y_0)(x-x_0)$$\n",
    "And the y-coordinate $y_1$ of the straight line at the point $x_0$ should be\n",
    "$$y_1=y_0+f(x_0,y_0)(x_1-x_0)=y_0+f(x_0,y_0)h$$\n",
    "If $h$ is very small, then $y_1 \\approx y(x_1)$, thus the point $(x_1,y_1)$ is fairly close to the point on the solution curve. If $f(x,y)$ is continuous, then the straight line starting from $(x_1,y_1)$ approximates the solution curve， with the function\n",
    "$$y=y_1+f(x_1,y_1)(x-x_1)$$\n",
    "And the y-coordinate of the end of this straight line is \n",
    "$$y_2=y_1+f(x_1,y_1)(x_2-x_1)$$\n",
    "And the rest can be done in the same manner, \n",
    "$$y_k=y_{k-1}+f(x_{k-1},y_{n-1})(x_{k}-x_{k-1})$$\n",
    "Since the function of every straight line is known, so for every point in the interval $[x_0,b]$, we can figure out the approxiamtion of the solution $y=y(x)$. And the fold line as the approximation of the solution is called the Euler Fold Line. It can be proven that when $n$ approaches infinity and $h$ approaches zero, the Euler fold line approaches the solution. \\[1\\]\n",
    "\n",
    "### Sensitivity and Robustness of Parameters \\[4\\]\n",
    "\n",
    "What we have and will be doing in this exercise has little to do with first principles of physics. Rather, they are just methematical modelling problems. As a result, it is necessary to discuss the sensitivity and robustness, two of the essential concepts in mathematical modelling. \n",
    "\n",
    "To set up a model describing a phenomenon, parameters play an important role in the final results of the model. These parameters are obtained from measurements, observations, and sometimes even by guess. So the inaccuracy of the data must be taken into consideration. Usually, for a certain extent of change of a parameter, the variable will change correspondingly. For the parameter $r$ and the variable $x$, \n",
    "$$\\lim_{\\Delta r \\rightarrow 0}\\frac{\\Delta x / x}{\\Delta r / r}=\\frac{dx}{dr} \\frac{r}{x}$$\n",
    "And we call this limit the _sensitivity_ of $x$ about $r$\n",
    "\n",
    "A mathematical model is called _robust_ if the result is still correct even if the model is not absolutely accurate. Sensitivity is a kind of index to evaluate the robustness of the model based on the data. Other assumptions will also be examined to ensure the robustness.\n",
    "\n",
    "In most questions after Chapter 1 of our textbook, we have been informed of the models to use and only have to realize the model through Python and cast the parameters into the program. So the sensitivity and robustness of our parameters become important.\n",
    "\n",
    "### Imaging with Python  \n",
    "\n",
    "It is convenient to draw plots with Python, since there have been the powerful packages `numpy` and `matplotlib`.\n",
    "\n",
    "`numpy` is a package that can deal with the discrete calculations that will be used in the ploting. Not only can it create number lists with the function `arrange` and `linspace`, it also contains the general math functions like the triangluar function `sin` `cos`.\\[5\\]\n",
    "\n",
    "`matplotlib` is the package that deal with the representation of plots. \\[6\\] Through the internal functions we can easily And other information about this package and the rebellish of pots can be found [here](http://www.labri.fr/perso/nrougier/teaching/matplotlib/).\n",
    "\n",
    "## Program   \n",
    "\n",
    "### Problem 1.5   \n",
    "\n",
    "> Consider again a decay problem with two types of nuclei A and B, but now suppose that nuclei of typw A decay into type B, while nuclei of type B decay into type A. Strictly speaking, this is not a \"decay\" process, since it is possible for the type B nuclei to turn back into type A. A better analogy would be a resonance in which a system can tunnel or move back and forth between two states A and B which have equal energies. The corresponding rate equations are\n",
    "> $$\\frac{dN_A}{dt}=\\frac{N_B}{\\tau}-\\frac{N_A}{\\tau}$$\n",
    "> $$\\frac{dN_B}{dt}=\\frac{N_A}{\\tau}-\\frac{N_B}{\\tau}$$\n",
    "> where for simplicity we have assumed that the two types of decay are characterized by the same time constant $\\tau$. Solve the system of equations for the numbers of nuclei, $N_A,N_B$ as functions of time. Consider different initial confitions, such as $N_A=100,\\ N_B=0$ etc, and take $\\tau=1s$. Show that your numerical results are consistent with the idea that the system reaches a steady state in which $N_A,N_B$ are constant. In such a steady state, the time derivatives $dN_A / dt,\\ dN_B / dt$ should vanish.\n",
    "\n",
    "### Declear and Initialize Variables and Parameters   \n",
    "\n",
    "Apparently the decay constants of A and B are important parameters. Here we have assumed that the two parameters equal. However, they do not necessarily have to be, so we declear `$\\tau_A$` and `$\\tau_B$` as separate parameters and initialize them with the same quantity.   \n",
    "Another parameter is the time interval for the Euler fold line to approximate the \"true\" solution of the equations. Apparently the smaller this parameter `dt` is, the closer our numerical solution will approach the true solution, but the slower the program will be. For convenience we set $dt\\ =\\ 0.1\\ second$ and will examine the effect of it value in the `Discussion` section.    \n",
    "And as an intuition, the system will become stable after certain amount of time. So we need a parameter `timescale` to control the time we want the system to develop.\n",
    "\n",
    "As for the variables, the solutions are the function $N_A(t)$ and $N_B(t)$. So we need two lists to store the value of $N_A$ and $N_B$ and a time list which has the same length of $N_A$ and $N_B$. The initial conditions are initialized as the first element of the lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tau=1\n",
    "tau_A=tau\n",
    "tau_B=tau\n",
    "dt=0.01\n",
    "timescale=5\n",
    "\n",
    "N_A=[100]  # the initial value of A\n",
    "N_B=[0]    # the initial value of B\n",
    "dN_A=[]    # \n",
    "dN_B=[]    # \n",
    "t=[0]      # to equate the length of t with A and B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculation   \n",
    "\n",
    "The algorithm of the problem is straightforward. We set up a cycle in which the new $N_A$ and $N_B$ value is obtained from the value of $N_A$ and $N_B$ before the time interval plus the product of the time interval and the derivative of $N_A$ and $N_B$ versus time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for cycle in range(int(timescale/dt)):\n",
    "    newNA=N_A[cycle]+(N_B[cycle]/tau_B-N_A[cycle]/tau_A)*dt\n",
    "    newNB=N_B[cycle]+(N_A[cycle]/tau_A-N_B[cycle]/tau_B)*dt\n",
    "    newtime=t[cycle]+dt\n",
    "    N_A.append(newNA)\n",
    "    N_B.append(newNB)\n",
    "    dN_A.append(N_B[cycle]/tau_B-N_A[cycle]/tau_A)\n",
    "    dN_B.append(N_A[cycle]/tau_A-N_B[cycle]/tau_B)\n",
    "    t.append(newtime)\n",
    "dN_A.append(dN_A[-1])\n",
    "dN_B.append(dN_B[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Represent and Restore the Results   \n",
    "\n",
    "Since the function $N_A$ and $N_B$ has been stored into the lists, we can plot them with the help of package `matplotlib`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import math\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# size of figure\n",
    "plt.figure(figsize=(16,12),dpi=80)\n",
    "plt.subplot(111)\n",
    "\n",
    "# plot the line, color, width, style\n",
    "plt.plot(t, N_A, color=\"blue\", linewidth=2.0, linestyle=\"-\", label=\"$N_A(t)$\")\n",
    "plt.plot(t, N_B, color=\"red\", linewidth=2.0, linestyle=\"-\", label=\"$N_B(t)$\")\n",
    "plt.plot(t, dN_A, color=\"blue\", linewidth=2.0, linestyle=\"--\", label=\"$dN_A(t)/dt$\")\n",
    "plt.plot(t, dN_B, color=\"red\", linewidth=2.0, linestyle=\"--\", label=\"$dN_B(t)/dt$\")\n",
    "\n",
    "# limits and ticks\n",
    "plt.xlim(min(t),max(t))\n",
    "plt.xticks([0,1,2,3,4,5])\n",
    "alldata=N_A+N_B\n",
    "plt.ylim(min(alldata), max(alldata))\n",
    "plt.yticks([0,20,40,60,80,100,120])\n",
    "plt.legend(loc=\"upper right\", frameon=False)\n",
    "\n",
    "# save and show figures in the tablet\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![4_1](https://raw.githubusercontent.com/ShixingWang/computationalphysics_N2013301020050/master/Pictures/4_1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The $dN_A(t)$ curve cannot be seen because it is below the x-axis. And it should be the mirror refelction of $dN_B(t)$(the proof is shown below).\n",
    "\n",
    "## Discussion   \n",
    "\n",
    "### Comparasion with Analytical Solution   \n",
    "\n",
    "According to the eigenvector mathod we can solve such ordinary differential equations fairly easily. For the equations with the boundary conditions\n",
    "$$\\begin{array}{llll}\\frac{dN_A}{dt}=\\frac{N_B}{\\tau_2}-\\frac{N_A}{\\tau_1}\\\\\n",
    "\\frac{dN_B}{dt}=\\frac{N_A}{\\tau_1}-\\frac{N_B}{\\tau_2}\\\\\n",
    "N_A(0)=N_{A_0}\\\\\n",
    "N_B(0)=N_{B_0}\\end{array}$$\n",
    "The analytical solution would be\n",
    "$$\\begin{array}{ll}N_A(t)= \\frac{(N_{A_0}+N_{B_0})\\tau_1}{\\tau_1+\\tau_2}+\\frac{-N_{B_0}\\tau_1+N_{A_0}\\tau_2}{\\tau_1+\\tau_2}e^{-(\\frac{1}{\\tau_1}+\\frac{1}{\\tau_2})t}\\\\\n",
    "N_B(t)= \\frac{(N_{A_0}+N_{B_0})\\tau_2}{\\tau_1+\\tau_2}+\\frac{N_{B_0}\\tau_1-N_{A_0}\\tau_2}{\\tau_1+\\tau_2}e^{-(\\frac{1}{\\tau_1}+\\frac{1}{\\tau_2})t}\\end{array}$$\n",
    "\n",
    "Our numerical solution show a exponential feature and the derivative about time vanish as time approaches infinity. And the \n",
    "\n",
    "This means the tendency of $N_A(t)$ and $N_B(t)$ depends on which of the two quantities $N_{B_0}\\tau_1$ and $N_{A_0}\\tau_2$ is greater. If the former is greater, then $N_A(t)$ decreases and $N_B(t)$ increases, and vice versa. And remind that at every time $N_A+N_B=const.$ So this process can also be treated as an exchange of states for a certain matter.\n",
    "\n",
    "![4_2](https://raw.githubusercontent.com/ShixingWang/computationalphysics_N2013301020050/master/Pictures/4_2.png)\n",
    "\n",
    "To draw several figures in the same picture we need the function `subplot`, and the settings of the ticks and limits of x-axis and y-axis are slightly different with `plot` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# size of figure\n",
    "plt.figure(figsize=(14,32),dpi=80)\n",
    "\n",
    "\n",
    "tau=1\n",
    "tau_A0=1.\n",
    "tau_B0=1.\n",
    "dt=0.01\n",
    "timescale0=5\n",
    "\n",
    "N_A0=[30]  # the initial value of A\n",
    "N_B0=[0]    # the initial value of B\n",
    "dN_A0=[]    # \n",
    "dN_B0=[]    # \n",
    "t0=[0]      # to equate the length of t with A and B\n",
    "\n",
    "for cycle0 in range(int(timescale0/dt)):\n",
    "    newNA0=N_A0[cycle0]+(N_B0[cycle0]/tau_B0-N_A0[cycle0]/tau_A0)*dt\n",
    "    newNB0=N_B0[cycle0]+(N_A0[cycle0]/tau_A0-N_B0[cycle0]/tau_B0)*dt\n",
    "    newtime0=t0[cycle0]+dt\n",
    "    N_A0.append(newNA0)\n",
    "    N_B0.append(newNB0)\n",
    "    dN_A0.append(N_B0[cycle0]/tau_B0-N_A0[cycle0]/tau_A0)\n",
    "    dN_B0.append(N_A0[cycle0]/tau_A0-N_B0[cycle0]/tau_B0)\n",
    "    t0.append(newtime0)\n",
    "dN_A0.append(dN_A0[-1])\n",
    "dN_B0.append(dN_B0[-1])\n",
    "\n",
    "p0=plt.subplot(221)\n",
    "\n",
    "# plot the line, color, width, style\n",
    "p0.set_title('$N_{A_0}=30$')\n",
    "p0.plot(t0, N_A0, color=\"blue\", linewidth=2.0, linestyle=\"-\", label=\"$N_A(t)$\")\n",
    "p0.plot(t0, N_B0, color=\"red\", linewidth=2.0, linestyle=\"-\", label=\"$N_B(t)$\")\n",
    "\n",
    "# limits and ticks\n",
    "p0.set_xlim(min(t0),max(t0))\n",
    "p0.set_xticks([1,2,3,4,5])\n",
    "alldata0=N_A0+N_B0\n",
    "p0.set_ylim(0, 120)\n",
    "p0.set_yticks([0,20,40,60,80,100,120])\n",
    "p0.legend(loc=\"right\", frameon=False)\n",
    "\n",
    "# -----------------------------Figure 1 Above----------------------------------\n",
    "\n",
    "tau=1\n",
    "tau_A=1\n",
    "tau_B=1\n",
    "dt=0.01\n",
    "timescale=5\n",
    "\n",
    "N_A=[60]  # the initial value of A\n",
    "N_B=[0]    # the initial value of B\n",
    "dN_A=[]    # \n",
    "dN_B=[]    # \n",
    "t=[0]      # to equate the length of t with A and B\n",
    "\n",
    "for cycle in range(int(timescale/dt)):\n",
    "    newNA=N_A[cycle]+(N_B[cycle]/tau_B-N_A[cycle]/tau_A)*dt\n",
    "    newNB=N_B[cycle]+(N_A[cycle]/tau_A-N_B[cycle]/tau_B)*dt\n",
    "    newtime=t[cycle]+dt\n",
    "    N_A.append(newNA)\n",
    "    N_B.append(newNB)\n",
    "    dN_A.append(N_B[cycle]/tau_B-N_A[cycle]/tau_A)\n",
    "    dN_B.append(N_A[cycle]/tau_A-N_B[cycle]/tau_B)\n",
    "    t.append(newtime)\n",
    "dN_A.append(dN_A[-1])\n",
    "dN_B.append(dN_B[-1])\n",
    "\n",
    "# size of figure\n",
    "p1=plt.subplot(222)\n",
    "\n",
    "# plot the line, color, width, style\n",
    "p1.set_title('$N_{A_0}=60$')\n",
    "p1.plot(t, N_A, color=\"blue\", linewidth=2.0, linestyle=\"-\", label=\"$N_A(t)$\")\n",
    "p1.plot(t, N_B, color=\"red\", linewidth=2.0, linestyle=\"-\", label=\"$N_B(t)$\")\n",
    "\n",
    "# limits and ticks\n",
    "p1.set_xlim(min(t),max(t))\n",
    "p1.set_xticks([0,1,2,3,4,5])\n",
    "alldata=N_A+N_B\n",
    "p1.set_ylim(min(alldata), max(alldata))\n",
    "p1.set_yticks([0,20,40,60,80,100,120])\n",
    "p1.legend(loc=\"upper right\", frameon=False)\n",
    "\n",
    "# -----------------------------Figure 2 Above----------------------------------\n",
    "\n",
    "tau=1\n",
    "tau_A2=1.\n",
    "tau_B2=1\n",
    "dt=0.01\n",
    "timescale=5\n",
    "\n",
    "N_A2=[90]  # the initial value of A\n",
    "N_B2=[0]    # the initial value of B\n",
    "dN_A2=[]    # \n",
    "dN_B2=[]    # \n",
    "t2=[0]      # to equate the length of t with A and B\n",
    "\n",
    "for cycle2 in range(int(timescale/dt)):\n",
    "    newNA2=N_A2[cycle2]+(N_B2[cycle2]/tau_B2-N_A2[cycle2]/tau_A2)*dt\n",
    "    newNB2=N_B2[cycle2]+(N_A2[cycle2]/tau_A2-N_B2[cycle2]/tau_B2)*dt\n",
    "    newtime2=t[cycle2]+dt\n",
    "    N_A2.append(newNA2)\n",
    "    N_B2.append(newNB2)\n",
    "    dN_A2.append(N_B2[cycle2]/tau_B2-N_A2[cycle2]/tau_A2)\n",
    "    dN_B2.append(N_A2[cycle2]/tau_A2-N_B2[cycle2]/tau_B2)\n",
    "    t2.append(newtime2)\n",
    "dN_A2.append(dN_A2[-1])\n",
    "dN_B2.append(dN_B2[-1])\n",
    "\n",
    "\n",
    "p2=plt.subplot(223)\n",
    "\n",
    "# plot the line, color, width, style\n",
    "p2.set_title('$N_{A_0}=90$')\n",
    "p2.plot(t2, N_A2, color=\"blue\", linewidth=2.0, linestyle=\"-\", label=\"$N_A(t)$\")\n",
    "p2.plot(t2, N_B2, color=\"red\", linewidth=2.0, linestyle=\"-\", label=\"$N_B(t)$\")\n",
    "\n",
    "# limits and ticks\n",
    "p2.set_xlim(min(t2),max(t2))\n",
    "p2.set_xticks([0,1,2,3,4,5])\n",
    "alldata2=N_A2+N_B2\n",
    "p2.set_ylim(0, 120)\n",
    "p2.set_yticks([0,20,40,60,80,100,120])\n",
    "p2.legend(loc=\"upper right\", frameon=False)\n",
    "\n",
    "# -----------------------------Figure 3 Above----------------------------------\n",
    "\n",
    "tau=1\n",
    "tau_A3=0.1\n",
    "tau_B3=1\n",
    "dt=0.01\n",
    "timescale3=5\n",
    "\n",
    "N_A3=[100]  # the initial value of A\n",
    "N_B3=[20]    # the initial value of B\n",
    "dN_A3=[]    # \n",
    "dN_B3=[]    # \n",
    "t3=[0]      # to equate the length of t with A and B\n",
    "\n",
    "for cycle3 in range(int(timescale3/dt)):\n",
    "    newNA3=N_A3[cycle3]+(N_B3[cycle3]/tau_B3-N_A3[cycle3]/tau_A3)*dt\n",
    "    newNB3=N_B3[cycle3]+(N_A3[cycle3]/tau_A3-N_B3[cycle3]/tau_B3)*dt\n",
    "    newtime3=t[cycle3]+dt\n",
    "    N_A3.append(newNA3)\n",
    "    N_B3.append(newNB3)\n",
    "    dN_A3.append(N_B3[cycle3]/tau_B3-N_A3[cycle3]/tau_A3)\n",
    "    dN_B3.append(N_A3[cycle3]/tau_A3-N_B3[cycle3]/tau_B3)\n",
    "    t3.append(newtime3)\n",
    "dN_A3.append(dN_A3[-1])\n",
    "dN_B3.append(dN_B3[-1])\n",
    "\n",
    "\n",
    "p3=plt.subplot(224)\n",
    "\n",
    "# plot the line, color, width, style\n",
    "p3.set_title('$N_{A_0}=100,N_{B_0}=20,\\tau_1=0.1,\\tau_2=1$')\n",
    "p3.plot(t3, N_A3, color=\"blue\", linewidth=2.0, linestyle=\"-\", label=\"$N_A(t)$\")\n",
    "p3.plot(t3, N_B3, color=\"red\", linewidth=2.0, linestyle=\"-\", label=\"$N_B(t)$\")\n",
    "\n",
    "# limits and ticks\n",
    "p3.set_xlim(min(t3),max(t3))\n",
    "p3.set_xticks([1,2,3,4,5])\n",
    "alldata3=N_A3+N_B3\n",
    "p3.set_ylim(0,120)\n",
    "p3.set_yticks([0,20,40,60,80,100,120])\n",
    "p3.legend(loc=\"right\", frameon=False)\n",
    "\n",
    "# -----------------------------Figure 4 Above----------------------------------\n",
    "# -----------------------------------------------------------------------------\n",
    "\n",
    "# save and show figures in the tablet\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sensitivity Analysis: How Will the Curve Shifts as Parameters Change?   \n",
    "\n",
    "#### Sensitivity of the Final Number about the Decay Constant\n",
    "According to the analytical solution, the number of A and B at the final state   \n",
    "$$N_A(\\infty)=\\lim_{t \\to \\infty}N_A(t)=(N_{A_0}+N_{B_0})\\frac{\\tau_1}{\\tau_1+\\tau_2}$$\n",
    "$$N_B(\\infty)=\\lim_{t\\to\\infty}N_B(t)=(N_{A_0}+N_{B_0})\\frac{\\tau_2}{\\tau_1+\\tau_2}$$\n",
    "The effect of the initial number of both matter is obviously linear, and the sensitivity will increase a little bit as $N_A$ and $N_B$ increase. This is because the respond of the final number is always smaller than the change of initial state.\n",
    "\n",
    "Here we choose the same decay constant ($\\tau_1=\\tau_2=1s$) and fix $N_B(0)=0$, to get the effect of different $N_{A_0}$\n",
    "\n",
    "![4_3](https://raw.githubusercontent.com/ShixingWang/computationalphysics_N2013301020050/master/Pictures/4_3.png)\n",
    "\n",
    "According to the Reference [4], the sensitivity of A and B about $\\tau_1$ and $\\tau_2$\n",
    "$$Sen(N_A(\\infty),\\tau_1)=\\frac{\\partial N_A(\\infty)}{\\partial \\tau_1}\\frac{\\tau_1}{N_A(\\infty)}=\\frac{\\tau_2}{\\tau_1+\\tau_2}$$\n",
    "$$Sen(N_A(\\infty),\\tau_2)=\\frac{\\partial N_A(\\infty)}{\\partial \\tau_2}\\frac{\\tau_2}{N_A(\\infty)}=-\\frac{\\tau_1}{\\tau_1+\\tau_2}$$\n",
    "$$Sen(N_B(\\infty),\\tau_1)=\\frac{\\partial N_B(\\infty)}{\\partial \\tau_1}\\frac{\\tau_1}{N_B(\\infty)}=\\frac{\\tau_1}{\\tau_1+\\tau_2}$$\n",
    "$$Sen(N_A(\\infty),\\tau_2)=\\frac{\\partial N_B(\\infty)}{\\partial \\tau_2}\\frac{\\tau_2}{N_B(\\infty)}=-\\frac{\\tau_2}{\\tau_1+\\tau_2}$$\n",
    "\n",
    "This means the sensitivities can never be over 1, and are independent with the initial number. \n",
    "\n",
    "Here we fix $N_{A_0}=100,\\ N_{B_0}=0$ and use various $\\tau_1$ and $\\tau_2$\n",
    "\n",
    "![4_4](https://raw.githubusercontent.com/ShixingWang/computationalphysics_N2013301020050/master/Pictures/4_4.png)\n",
    "\n",
    "### Robustness Analysis: Does Time Steplength Matter?   \n",
    "\n",
    "As is introduced in the `Background` section, the validity of Euler method depends on the Euler fold line as the approximation of the true solution curve. Specifically, it depends on the fact that the iterating interval is ralatively small comparing to the system of interest. But how big can this interval be? We tried several length of interval and the resluts are shown below.\n",
    "\n",
    "![4_5](https://raw.githubusercontent.com/ShixingWang/computationalphysics_N2013301020050/master/Pictures/4_5.png)\n",
    "\n",
    "\n",
    "\n",
    "## Acknowledgement     \n",
    "All the codes and report are written by myself.    \n",
    "I must give my appreciation to FC Bayern Munchen club for their exciting victory in Allianz Arena against Juventus. They gave me an excellent weekend so that I can finish this exercise joyfully! Really looking forward to their highlight performance in Milan!\n",
    "##### MIA SAN MIA!\n",
    "\n",
    "\n",
    "## Reference   \n",
    "\n",
    "[1] Differential Equation Group of Northeast University. Ordinary Differential Equation, Second Edition. Higher Education Press, April 2005.     \n",
    "\n",
    "[2] Qi, Minyou et al. Advanced Mathematics. Wuhan University Press, August 2008.      \n",
    "\n",
    "[3] Wikipedia contributors. \"Taylor series.\" Wikipedia, The Free Encyclopedia. Wikipedia, The Free Encyclopedia, 20 Mar. 2016. Web. 22 Mar. 2016.      \n",
    "\n",
    "[4] Meerschaert, Mark M. Mathematical Modelling,Fourth Edition. China Machine Press, Janurary 1, 2015.\n",
    "\n",
    "[5] \"lectery\", a Baidu user. Maypoltlib Guidebook.     \n",
    "[http://wenku.baidu.com/link?url=haYK7EyFYYblwual6X1lAihWbvIFvYWx2MvEclbgARNn76kNJO9kU0Fb6R40YPuA71iHk60fD7HX_9PCaDTTuulVSRLcQwopIngL6uZjNpW](http://wenku.baidu.com/link?url=haYK7EyFYYblwual6X1lAihWbvIFvYWx2MvEclbgARNn76kNJO9kU0Fb6R40YPuA71iHk60fD7HX_9PCaDTTuulVSRLcQwopIngL6uZjNpW)    \n",
    "\n",
    "[6] Nicolas P. Rougier. Matplotlib Tutorial. [http://www.labri.fr/perso/nrougier/teaching/matplotlib/](http://www.labri.fr/perso/nrougier/teaching/matplotlib/)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}