07b_deconvolution_definitions.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Load the NG data and the response function and dump output into variables\n",
    "from IPython.utils import io\n",
    "with io.capture_output() as output_03:\n",
    "    %run '03b_bear_necessities.ipynb'\n",
    "with io.capture_output() as output_05:\n",
    "    %run '05_response function.ipynb'\n",
    "# with io.capture_output() as output_10:\n",
    "#     %run '10_read_andreas_result.ipynb'\n",
    "# with io.capture_output() as output_12:\n",
    "#     %run '12_read_simu.ipynb'\n",
    "# with io.capture_output() as output_14:\n",
    "#     %run '14_a_closer_look_at_acceptance.ipynb'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We define a couple of functions here. These assume a (combination of some) Gaussian in neutron incident energy. For the convolution, we need to sample in neutron_energies list, but for the fit, we need to resample to match the energy scale in measurement. This is split into two functions. Clear? For a neutron spectrum, just plot a Gauss!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def get_neutron_spectrum(mu, sigma):\n",
    "    '''\n",
    "    Recoil space.\n",
    "    Get the smeared version of the response for an original neutron spectrum that is Gaussian in energy.\n",
    "    Mu and sigma in MeV please.\n",
    "    Requires globally defined 'neutron_energies', 'electron_energies' and 'response'\n",
    "    '''\n",
    "    # The parameter 'electron_energies'  comes from the presupplied response function \n",
    "    smeared_response = np.zeros(len(electron_energies))\n",
    "    \n",
    "    # Loop over all neutron energy bins expect for last one\n",
    "    for i in range(len(neutron_energies) - 1):\n",
    "        # Current neutron energy\n",
    "        neutron_energy = neutron_energies[i]\n",
    "        # Current bin width\n",
    "        bin_width = neutron_energies[i+1] - neutron_energies[i]\n",
    "        # Current amplitude in the neutron spectrum\n",
    "        ampl = gaussian(neutron_energy, mu, sigma)\n",
    "        # Full response for this neutron energy bin\n",
    "        smeared_response += bin_width*ampl*response[i]\n",
    "    return smeared_response\n",
    "\n",
    "\n",
    "def get_neutron_spectrum_interpolated(energy_list, a, mu, sigma):\n",
    "    '''\n",
    "    Recoil space\n",
    "    Interpolate the function that we get from 'get_neutron_spectrum'  to fit 'energy_list'\n",
    "    '''\n",
    "    smeared_response = get_neutron_spectrum(mu, sigma)\n",
    "    return a * np.interp(energy_list, 1000*electron_energies, smeared_response)\n",
    "\n",
    "def get_neutron_spectrum_interpolated_2(energy_list, a1, mu1, sigma1, a2, mu2, sigma2):\n",
    "    '''\n",
    "    Two copies of get_neutron_spectrum_interpolated for fitting of two energy populations\n",
    "    '''\n",
    "    smeared_response1 = get_neutron_spectrum(mu1, sigma1)\n",
    "    smeared_response2 = get_neutron_spectrum(mu2, sigma2)\n",
    "    return ( a1 * np.interp(energy_list, 1000*electron_energies, smeared_response1) +\n",
    "            a2 * np.interp(energy_list, 1000*electron_energies, smeared_response2))\n",
    "\n",
    "def get_neutron_spectrum_interpolated_3(energy_list, \n",
    "                                        a1, mu1, sigma1,\n",
    "                                        a2, mu2, sigma2, \n",
    "                                        a3, mu3, sigma3):\n",
    "    '''\n",
    "    Three copies of get_neutron_spectrum_interpolated for fitting of three energy populations\n",
    "    '''\n",
    "    smeared_response1 = get_neutron_spectrum(mu1, sigma1)\n",
    "    smeared_response2 = get_neutron_spectrum(mu2, sigma2)\n",
    "    smeared_response3 = get_neutron_spectrum(mu3, sigma3)\n",
    "    return ( a1 * np.interp(energy_list, 1000*electron_energies, smeared_response1) +\n",
    "            a2 * np.interp(energy_list, 1000*electron_energies, smeared_response2) +\n",
    "           a3 * np.interp(energy_list, 1000*electron_energies, smeared_response3))\n",
    "\n",
    "def get_chi_sq(y_data, y_err, y_fit):\n",
    "    '''\n",
    "    This function is only used in 'manual minimization' so it is depricated\n",
    "    '''\n",
    "    print('DepricationWarning')\n",
    "    return sum((y_fit - y_data)**2/(y_err**2))\n",
    "\n",
    "def draw_box(x, y, **kwargs):\n",
    "    \"\"\"Draw rectangle, given x-y boundary tuples\"\"\"\n",
    "    import matplotlib as mpl\n",
    "    # Arcane syntax of the week: matplotlib's Rectangle...\n",
    "    plt.gca().add_patch(mpl.patches.Rectangle(\n",
    "        (x[0], y[0]), x[1] - x[0], y[1] - y[0], **kwargs))\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It gets a bit more complicated: we want to do this little bit for ANY neutron spectrum, specified by an energy spectrum (that follows distribution according to neutron_energies, again!). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\n",
    "def get_neutron_spectrum_custom(amp_list):\n",
    "    '''\n",
    "    Recoil space\n",
    "    Use a custom list of amplitudes\n",
    "    Mu and sigma in MeV please.\n",
    "    Requires globally defined 'neutron_energies', 'electron_energies' and 'response'\n",
    "    '''\n",
    "    \n",
    "    assert(len(amp_list) == len(neutron_energies))\n",
    "    \n",
    "    # The parameter 'electron_energies'  comes from the presupplied response function \n",
    "    smeared_response = np.zeros(len(electron_energies))\n",
    "    \n",
    "    # Loop over all neutron energy bins expect for last one\n",
    "    for i in range(len(neutron_energies) - 1):\n",
    "        # Current neutron energy\n",
    "        neutron_energy = neutron_energies[i]\n",
    "        # Current bin width\n",
    "        bin_width = neutron_energies[i+1] - neutron_energies[i]\n",
    "        # Current amplitude in the neutron spectrum\n",
    "        ampl = amp_list[i]\n",
    "        # Full response for this neutron energy bin\n",
    "        smeared_response += bin_width*ampl*response[i]\n",
    "    return smeared_response\n",
    "\n",
    "def get_neutron_spectrum_custom_interpolated(energy_list, amp_list):\n",
    "    '''\n",
    "    Recoil space\n",
    "    Amp_list follows neutron_energies!\n",
    "    Output is y to whatever x you specify with energy_list (how about e_scale?)\n",
    "    '''\n",
    "    smeared_response = get_neutron_spectrum_custom(amp_list)\n",
    "    return np.interp(energy_list, 1000*electron_energies, smeared_response)"
   ]
  }
 ],
 "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.5"
  },
  "latex_envs": {
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 0
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}