usALEX-5samples-E-corrected-all-ph.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# usALEX-5samples - Template\n",
    "\n",
    "> *This notebook is executed through [8-spots paper analysis](8-spots paper analysis.ipynb).*\n",
    "> *For a direct execution, uncomment the cell below.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# data_id = \"7d\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load software and filenames definitions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from fretbursts import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "init_notebook()\n",
    "from IPython.display import display"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data folder:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "data_dir = './data/singlespot/'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import os\n",
    "data_dir = os.path.abspath(data_dir) + '/'\n",
    "assert os.path.exists(data_dir), \"Path '%s' does not exist.\" % data_dir"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List of data files:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from glob import glob\n",
    "file_list = sorted(f for f in glob(data_dir + '*.hdf5') if '_BKG' not in f)\n",
    "## Selection for POLIMI 2012-11-26 datatset\n",
    "labels = ['17d', '27d', '7d', '12d', '22d']\n",
    "files_dict = {lab: fname for lab, fname in zip(labels, file_list)}\n",
    "files_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "data_id"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data load"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initial loading of the data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "d = loader.photon_hdf5(filename=files_dict[data_id])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load the **leakage coefficient** from disk:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "leakage_coeff_fname = 'results/usALEX - leakage coefficient DexDem.csv'\n",
    "leakage = np.loadtxt(leakage_coeff_fname)\n",
    "\n",
    "print('Leakage coefficient:', leakage)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load the **direct excitation coefficient** ($d_{exAA}$) from disk:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "dir_ex_coeff_fname = 'results/usALEX - direct excitation coefficient dir_ex_aa.csv'\n",
    "dir_ex_aa = np.loadtxt(dir_ex_coeff_fname)\n",
    "\n",
    "print('Direct excitation coefficient (dir_ex_aa):', dir_ex_aa)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load the **gamma-factor** ($\\gamma$) from disk:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "gamma_fname = 'results/usALEX - gamma factor - all-ph.csv'\n",
    "gamma = np.loadtxt(gamma_fname)\n",
    "\n",
    "print('Gamma-factor:', gamma)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Update `d` with the correction coefficients:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "d.leakage = leakage\n",
    "d.dir_ex = dir_ex_aa\n",
    "d.gamma = gamma"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Laser alternation selection\n",
    "\n",
    "At this point we have only the timestamps and the detector numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "d.ph_times_t[0][:3], d.ph_times_t[0][-3:]#, d.det_t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print('First and last timestamps:  {:10,}  {:10,}'.format(d.ph_times_t[0][0], d.ph_times_t[0][-1]))\n",
    "print('Total number of timestamps: {:10,}'.format(d.ph_times_t[0].size))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to define some parameters: donor and acceptor ch, excitation period and donor and acceptor excitiations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "d.add(det_donor_accept=(0, 1), alex_period=4000, D_ON=(2850, 580), A_ON=(900, 2580), offset=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We should check if everithing is OK with an alternation histogram:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plot_alternation_hist(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the plot looks good we can apply the parameters with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "loader.alex_apply_period(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print('D+A photons in D-excitation period: {:10,}'.format(d.D_ex[0].sum()))\n",
    "print('D+A photons in A-excitation period: {:10,}'.format(d.A_ex[0].sum()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Measurements infos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All the measurement data is in the `d` variable. We can print it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or check the **measurements duration**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "d.time_max"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compute background"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute the background using automatic threshold:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "d.calc_bg(bg.exp_fit, time_s=60, tail_min_us='auto', F_bg=1.7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "dplot(d, timetrace_bg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "d.rate_m, d.rate_dd, d.rate_ad, d.rate_aa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Burst search and selection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "d.burst_search(L=10, m=10, F=7, ph_sel=Ph_sel('all'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(d.ph_sel)\n",
    "dplot(d, hist_fret);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# if data_id in ['7d', '27d']:\n",
    "#     ds = d.select_bursts(select_bursts.size, th1=20)\n",
    "# else:\n",
    "#     ds = d.select_bursts(select_bursts.size, th1=30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ds = d.select_bursts(select_bursts.size, add_naa=False, th1=30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "n_bursts_all = ds.num_bursts[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def select_and_plot_ES(fret_sel, do_sel):\n",
    "    ds_fret= ds.select_bursts(select_bursts.ES, **fret_sel)\n",
    "    ds_do = ds.select_bursts(select_bursts.ES, **do_sel)\n",
    "    bpl.plot_ES_selection(ax, **fret_sel)\n",
    "    bpl.plot_ES_selection(ax, **do_sel)    \n",
    "    return ds_fret, ds_do"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ax = dplot(ds, hist2d_alex, S_max_norm=2, scatter_alpha=0.1)\n",
    "\n",
    "if data_id == '7d':\n",
    "    fret_sel = dict(E1=0.60, E2=1.2, S1=0.2, S2=0.9, rect=False)\n",
    "    do_sel = dict(E1=-0.2, E2=0.5, S1=0.8, S2=2, rect=True)    \n",
    "    ds_fret, ds_do = select_and_plot_ES(fret_sel, do_sel)\n",
    "    \n",
    "elif data_id == '12d':\n",
    "    fret_sel = dict(E1=0.30,E2=1.2,S1=0.131,S2=0.9, rect=False)\n",
    "    do_sel = dict(E1=-0.4, E2=0.4, S1=0.8, S2=2, rect=False)\n",
    "    ds_fret, ds_do = select_and_plot_ES(fret_sel, do_sel)\n",
    "\n",
    "elif data_id == '17d':\n",
    "    fret_sel = dict(E1=0.01, E2=0.98, S1=0.14, S2=0.88, rect=False)\n",
    "    do_sel = dict(E1=-0.4, E2=0.4, S1=0.80, S2=2, rect=False)\n",
    "    ds_fret, ds_do = select_and_plot_ES(fret_sel, do_sel)\n",
    "\n",
    "elif data_id == '22d':\n",
    "    fret_sel = dict(E1=-0.16, E2=0.6, S1=0.2, S2=0.80, rect=False)\n",
    "    do_sel = dict(E1=-0.2, E2=0.4, S1=0.85, S2=2, rect=True)\n",
    "    ds_fret, ds_do = select_and_plot_ES(fret_sel, do_sel)    \n",
    "\n",
    "elif data_id == '27d':\n",
    "    fret_sel = dict(E1=-0.1, E2=0.5, S1=0.2, S2=0.82, rect=False)\n",
    "    do_sel = dict(E1=-0.2, E2=0.4, S1=0.88, S2=2, rect=True)\n",
    "    ds_fret, ds_do = select_and_plot_ES(fret_sel, do_sel)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "n_bursts_do = ds_do.num_bursts[0]\n",
    "n_bursts_fret = ds_fret.num_bursts[0]\n",
    "\n",
    "n_bursts_do, n_bursts_fret"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "d_only_frac = 1.*n_bursts_do/(n_bursts_do + n_bursts_fret)\n",
    "print('D-only fraction:', d_only_frac)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "dplot(ds_fret, hist2d_alex, scatter_alpha=0.1);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "dplot(ds_do, hist2d_alex, S_max_norm=2, scatter=False);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Donor Leakage fit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "bandwidth = 0.03\n",
    "\n",
    "E_range_do = (-0.1, 0.15)\n",
    "E_ax = np.r_[-0.2:0.401:0.0002]\n",
    "\n",
    "E_pr_do_kde = bext.fit_bursts_kde_peak(ds_do, bandwidth=bandwidth, weights='size', \n",
    "                                       x_range=E_range_do, x_ax=E_ax, save_fitter=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mfit.plot_mfit(ds_do.E_fitter, plot_kde=True, bins=np.r_[E_ax.min(): E_ax.max(): bandwidth])\n",
    "plt.xlim(-0.3, 0.5)\n",
    "print(\"%s: E_peak = %.2f%%\" % (ds.ph_sel, E_pr_do_kde*100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Burst sizes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "nt_th1 = 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dplot(ds_fret, hist_size, which='all', add_naa=False)\n",
    "xlim(-0, 250)\n",
    "plt.axvline(nt_th1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "Th_nt = np.arange(35, 120)\n",
    "nt_th = np.zeros(Th_nt.size)\n",
    "for i, th in enumerate(Th_nt):\n",
    "    ds_nt = ds_fret.select_bursts(select_bursts.size, th1=th)\n",
    "    nt_th[i] = (ds_nt.nd[0]  + ds_nt.na[0]).mean() - th"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.figure()\n",
    "plot(Th_nt, nt_th)\n",
    "plt.axvline(nt_th1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "nt_mean = nt_th[np.where(Th_nt == nt_th1)][0]\n",
    "nt_mean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fret fit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Max position of the Kernel Density Estimation (KDE):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "E_pr_fret_kde = bext.fit_bursts_kde_peak(ds_fret, bandwidth=bandwidth, weights='size')\n",
    "E_fitter = ds_fret.E_fitter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "E_fitter.histogram(bins=np.r_[-0.1:1.1:0.03])\n",
    "E_fitter.fit_histogram(mfit.factory_gaussian(center=0.5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "E_fitter.fit_res[0].params.pretty_print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(1, 2, figsize=(14, 4.5))\n",
    "mfit.plot_mfit(E_fitter, ax=ax[0])\n",
    "mfit.plot_mfit(E_fitter, plot_model=False, plot_kde=True, ax=ax[1])\n",
    "print('%s\\nKDE peak %.2f ' % (ds_fret.ph_sel, E_pr_fret_kde*100))\n",
    "display(E_fitter.params*100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Weighted mean of $E$ of each burst:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ds_fret.fit_E_m(weights='size')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Gaussian fit (no weights):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ds_fret.fit_E_generic(fit_fun=bl.gaussian_fit_hist, bins=np.r_[-0.1:1.1:0.03], weights=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Gaussian fit (using burst size as weights):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ds_fret.fit_E_generic(fit_fun=bl.gaussian_fit_hist, bins=np.r_[-0.1:1.1:0.005], weights='size')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "E_kde_w = E_fitter.kde_max_pos[0]\n",
    "E_gauss_w = E_fitter.params.loc[0, 'center']\n",
    "E_gauss_w_sig = E_fitter.params.loc[0, 'sigma']\n",
    "E_gauss_w_err = float(E_gauss_w_sig/np.sqrt(ds_fret.num_bursts[0]))\n",
    "E_gauss_w_fiterr = E_fitter.fit_res[0].params['center'].stderr\n",
    "E_kde_w, E_gauss_w, E_gauss_w_sig, E_gauss_w_err, E_gauss_w_fiterr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Stoichiometry fit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Max position of the Kernel Density Estimation (KDE):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "S_pr_fret_kde = bext.fit_bursts_kde_peak(ds_fret, burst_data='S', bandwidth=0.03) #weights='size', add_naa=True)\n",
    "S_fitter = ds_fret.S_fitter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "S_fitter.histogram(bins=np.r_[-0.1:1.1:0.03])\n",
    "S_fitter.fit_histogram(mfit.factory_gaussian(), center=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(1, 2, figsize=(14, 4.5))\n",
    "mfit.plot_mfit(S_fitter, ax=ax[0])\n",
    "mfit.plot_mfit(S_fitter, plot_model=False, plot_kde=True, ax=ax[1])\n",
    "print('%s\\nKDE peak %.2f ' % (ds_fret.ph_sel, S_pr_fret_kde*100))\n",
    "display(S_fitter.params*100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "S_kde = S_fitter.kde_max_pos[0]\n",
    "S_gauss = S_fitter.params.loc[0, 'center']\n",
    "S_gauss_sig = S_fitter.params.loc[0, 'sigma']\n",
    "S_gauss_err = float(S_gauss_sig/np.sqrt(ds_fret.num_bursts[0]))\n",
    "S_gauss_fiterr = S_fitter.fit_res[0].params['center'].stderr\n",
    "S_kde, S_gauss, S_gauss_sig, S_gauss_err, S_gauss_fiterr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Maximum likelihood fit for a Gaussian population is the mean:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "S = ds_fret.S[0]\n",
    "S_ml_fit = (S.mean(), S.std())\n",
    "S_ml_fit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Computing the weighted mean and weighted standard deviation we get:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "weights = bl.fret_fit.get_weights(ds_fret.nd[0], ds_fret.na[0], weights='size', naa=ds_fret.naa[0], gamma=1.)\n",
    "S_mean = np.dot(weights, S)/weights.sum()\n",
    "S_std_dev = np.sqrt(\n",
    "        np.dot(weights, (S - S_mean)**2)/weights.sum())\n",
    "S_wmean_fit = [S_mean, S_std_dev]\n",
    "S_wmean_fit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Save data to file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "sample = data_id"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following string contains the list of variables to be saved. When saving, the order of the variables is preserved."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "variables = ('sample n_bursts_all n_bursts_do n_bursts_fret '\n",
    "             'E_kde_w E_gauss_w E_gauss_w_sig E_gauss_w_err E_gauss_w_fiterr '\n",
    "             'S_kde S_gauss S_gauss_sig S_gauss_err S_gauss_fiterr '\n",
    "             'E_pr_do_kde nt_mean\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is just a trick to format the different variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "variables_csv = variables.replace(' ', ',')\n",
    "fmt_float = '{%s:.6f}'\n",
    "fmt_int = '{%s:d}'\n",
    "fmt_str = '{%s}'\n",
    "fmt_dict = {**{'sample': fmt_str}, \n",
    "            **{k: fmt_int for k in variables.split() if k.startswith('n_bursts')}}\n",
    "var_dict = {name: eval(name) for name in variables.split()}\n",
    "var_fmt = ', '.join([fmt_dict.get(name, fmt_float) % name for name in variables.split()]) + '\\n'\n",
    "data_str = var_fmt.format(**var_dict)\n",
    "\n",
    "print(variables_csv)\n",
    "print(data_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# NOTE: The file name should be the notebook name but with .csv extension\n",
    "with open('results/usALEX-5samples-E-corrected-all-ph.csv', 'a') as f:\n",
    "    f.seek(0, 2)\n",
    "    if f.tell() == 0:\n",
    "        f.write(variables_csv)\n",
    "    f.write(data_str)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}