notebooks/FRETBursts - ns-ALEX example.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:2e19d4de06274a847cd982090445b5e75113cdabcdbbe1022d92e6495c1f6425"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "#FRETBursts - ns-ALEX example\n",
      "\n",
      "*This notebook is part of a [tutorial series](https://github.com/tritemio/FRETBursts_notebooks) for the [FRETBursts](http://tritemio.github.io/FRETBursts/) burst analysis software.*"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "> For a step-by-step introduction to FRETBursts usage please refer to [us-ALEX smFRET burst analysis](FRETBursts - us-ALEX smFRET burst analysis.ipynb).\n",
      ">\n",
      "> In this notebook we present a typical [FRETBursts](https://github.com/tritemio/FRETBursts/)\n",
      "> workflow for **ns-ALEX smFRET burst analysis**. \n",
      "\n",
      "*While FRETBursts does not specifically includes functions for fitting TCSPC fluorescence decays, a fitting with exponetial decays and IRF deconvolution can be easily performed using standard python libraries. For an example and a brief discussion see the notebook [Lifetime decay fit](http://nbviewer.ipython.org/github/tritemio/notebooks/blob/master/Lifetime_decay_fit.ipynb).*"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Loading FRETBursts"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from fretbursts import *"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Selecting a data file\n",
      "\n",
      "The following command will an open-file dialog in order to select a data file:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "fname = gui_fname(r'C:\\Data')\n",
      "fname"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Load the selected file\n",
      "\n",
      "Here we load the file and we set the alternation parameters:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "d = loader.nsalex(fname)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "d.time_max()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "d.det_t"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.unique(d.det_t)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "d.add(D_ON=(150, 1100), A_ON=(1200, 2050), det_donor_accept=(0, 2))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "bpl.plot_alternation_hist_nsalex(d)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Execute the previous 2 cells untill you get a satisfying selection for the excitation periods. Then run the following to apply the parameters:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "loader.nsalex_apply_period(d)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "##Burst search and selection"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "d.calc_bg(fun=bg.exp_fit, time_s=30, tail_min_us='auto', F_bg=1.7)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dplot(d, timetrace_bg)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dplot(d, timetrace_da)\n",
      "xlim(1, 2)\n",
      "ylim(-50, 50)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "d.burst_search_t()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "ds = Sel(d, select_bursts.size, th1=30)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dplot(ds, hist2d_alex)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "ds.update_leakage(0.09)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dplot(ds, hist2d_alex)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dplot(ds, hist_fret_kde)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Nano-time\n",
      "\n",
      "The nanotime for the measurement is saved in the `.nanotime` attribute of the `Data()` variable (here either `d` or `ds`).\n",
      "\n",
      "As an example here we get the array of nanotimes for all photons, donor emission and acceptor emsission:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "nanotimes_t = d.nanotimes\n",
      "nanotimes_d = d.nanotimes[d.get_D_em()]\n",
      "nanotimes_a = d.nanotimes[d.get_A_em()]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We can plot the histogram for this 3 nanotimes:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "hist_params = dict(bins=range(4096), histtype='step', alpha=0.6, lw=1.5)\n",
      "hist(nanotimes_t, color='k', label='Total ph.', **hist_params)\n",
      "hist(nanotimes_d, color='g', label='D. em. ph.', **hist_params)\n",
      "hist(nanotimes_a, color='r', label='A. em. ph.', **hist_params)\n",
      "plt.legend()\n",
      "xlim(0, 2000)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We can also select only nanotimes of photons inside bursts. Here, as an example, we will use the `ds` variable that contains a selection of bursts.\n",
      "\n",
      "First we compute a selection mask (a boolean array) for photons inside bursts:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "ph_in_bursts_mask = bl.ph_select(ds.ph_times_m[0], ds.mburst[0])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Then we apply this selection to the nanotimes array. To get the donor- and acceptor-emission nanotimes we combine the in-bursts selection mask (`ph_in_bursts_mask`) with the donor or acceptor emission mask (that we get with `.get_D_em()` and `.get_D_em()`):"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "bursts_nanotimes_t = d.nanotimes[ph_in_bursts_mask]\n",
      "bursts_nanotimes_d = d.nanotimes[ph_in_bursts_mask * d.get_D_em()]\n",
      "bursts_nanotimes_a = d.nanotimes[ph_in_bursts_mask * d.get_A_em()]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "And, as before, we can histogram the nanotimes:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "hist_params = dict(bins=range(4096), histtype='step', alpha=0.6, lw=1.5)\n",
      "hist(bursts_nanotimes_t, color='k', label='Total ph.', **hist_params)\n",
      "hist(bursts_nanotimes_d, color='g', label='D. em. ph.', **hist_params)\n",
      "hist(bursts_nanotimes_a, color='r', label='A. em. ph.', **hist_params)\n",
      "plt.legend()\n",
      "xlim(0, 2000)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "##Saving to a file\n",
      "\n",
      "Saving some of all these arrays to file is straightforward. Let see some examples."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Save array to txt comma-separed-values\n",
      "\n",
      "To save a single array to a file we can use the [`.tofile`](http://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.tofile.html) method:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "with open('nanotimes_t.txt', 'w') as f:\n",
      "    nanotimes_t.tofile(f, sep=',\\n')  # save in CSV txt format"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Save to MATLAB format\n",
      "\n",
      "To save a set of arrays in MATLAB format  we can use the [`scipy.io.savemat`](http://docs.scipy.org/doc/scipy-0.13.0/reference/generated/scipy.io.savemat.html) function.\n",
      "\n",
      "Here we save 3 arrays `bursts_nanotimes_t`, `bursts_nanotimes_d` and `bursts_nanotimes_a` to a file called *bursts_nanotimes.mat*:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from scipy.io import savemat"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "savemat('bursts_nanotimes.mat', \n",
      "        dict(bn_t=bursts_nanotimes_t, \n",
      "             bn_d=bursts_nanotimes_d, \n",
      "             bn_a=bursts_nanotimes_a,))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "When loaded in MATLAB the arrays will be named `bn_t`, `bn_d` and `bn_a`."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "#Notebook style"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from IPython.core.display import HTML\n",
      "HTML(open(\"./styles/custom.css\", \"r\").read())"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}