form_for_decay_function.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comment from Simon\n",
    "The other major concern I have is equation 1. I guess that this is only valid for t>0 ? Otherwise it explodes at negative delays. If this is the case, I don’t really see the point/reason of fitting “half” an error function. I would say an error function is something you fit when the dynamics are resolution limited (this is what we say in the text). What does this mean? It means that we should see some signal for times t<0 because of our finite blurring on the time axis. If we restrict the fit to only times >0 we are not fitting the error function correctly.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Response\n",
    "It's true that the exponential functions needs to be modified not to exceed one for $t<0$, but this is true of the the suggested revised form as well. If the expoentials are suitably set, the fit can be applied over the whole function -- which we agree is desirable and which we do already. \n",
    "\n",
    "Our view is the decay is time-resolution-limited and I think time zero was indeed not set so well in earlier drafts. We have now corrected time zero in the draft. We also corrected a bad typo on our part where we had a missing minus sign in the erf function.  \n",
    "\n",
    "We have looked at the proposed new form you sent below. I think there might be some typos? We tried a couple of modifications to try to get at what you had in mind, but we didn't have much luck. Please can you check and advise us. \n",
    "\n",
    "Overall, now that we've corrected time zero, and the typo in the equation, I can't see any serious issues with what we have and would be inclinded to keep it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from scipy.special import erf\n",
    "import matplotlib.pyplot as plt\n",
    "from ipywidgets import interact, interactive, FloatSlider\n",
    "from IPython.display import display\n",
    "\n",
    "%matplotlib widget"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib widget"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Evaluate original form"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the email, the suggested form is  \n",
    "$I(t) = I_0/2 + \\frac{1}{2} (1+\\text{erf}(t))(A*\\exp(-t/t_{mag})+C(1-\\exp(-t/t_{mag})) + B*\\sin…)$\n",
    "\n",
    "I think $I_0$ is actually more appropriate than $I_0/2$.\n",
    "\n",
    "The functional behavior is clear if you take the $t_{erf} << t_{mag}$ limit.  \n",
    "\n",
    "* $-A$ is the drop \n",
    "* $-C$ is the amount of order that fails to recover  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "cf4b8fef922b49d79cd413818bc599dd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c4874e5879d549c386a78c7c9d7b88b0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=1.0, description='I_0', max=3.0, min=-1.0), FloatSlider(value=0.15, de…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.plot_revised_form(I_0=1.0, t_erf=0.15, A=0.5, C=0.2, t_mag=5)>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = np.linspace(-3, 100, 5000)\n",
    "\n",
    "def exp(x):\n",
    "    y = np.exp(x)\n",
    "    y[y>1] = 1\n",
    "    return y\n",
    "\n",
    "def revised_form(t, I_0, t_erf, A, C, t_mag):\n",
    "    I = I_0 + 0.5*(1+erf(t/t_erf))*(A*exp(-t/t_mag)+C*(1-exp(-t/t_mag)))\n",
    "    \n",
    "    return I\n",
    "\n",
    "def plot_revised_form(I_0=1., t_erf=.15, A=0.5, C=0.2, t_mag=5):\n",
    "    I = revised_form(t, I_0=I_0, t_erf=t_erf, A=A, C=C, t_mag=t_mag)\n",
    "    art.set_ydata(I)\n",
    "    fig.canvas.draw()\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "I = revised_form(t, I_0=1, t_erf=.01, A=-.8, C=.5, t_mag=5)\n",
    "art,  = ax.plot(t, I)\n",
    "ax.set_xlabel('t')\n",
    "ax.set_ylabel('I')\n",
    "ax.set_ylim((-4, 10))\n",
    "\n",
    "def update(I=1):\n",
    "    art.set_ydata(t*0 + I)\n",
    "    fig.canvas.draw()\n",
    "\n",
    "interact(plot_revised_form,\n",
    "         I0=FloatSlider(value=1, min=0, max=2),\n",
    "         t_erf=FloatSlider(value=0.15, min=0.00001, max=3, step=0.0001),\n",
    "         A=FloatSlider(value=-.9, min=-5, max=1),\n",
    "         C=FloatSlider(value=-.2, min=-5, max=1),\n",
    "         t_mag=FloatSlider(value=.5, min=0, max=5, step=0.01),\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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}