POP2p.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cellsim.Rm as mm\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import seaborn as sns\n",
    "from pandas import IndexSlice as idx\n",
    "from multiprocessing import Pool\n",
    "from copy import deepcopy as dcopy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import c14\n",
    "from c14.models import liver_new_mitosis as lm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with pd.HDFStore('point_est.pandas') as st:\n",
    "    point_est = st['F_IS_spline_newploidy'] \n",
    "para=dict(point_est.loc['Rmspline','median'].dropna())\n",
    "para"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = lm.Rm(dnatotal=lm.dnatotal_spline)\n",
    "m.set_parameters_phy(para,mode='bayes')\n",
    "ips =[]\n",
    "T = np.arange(0,90,0.1)\n",
    "for i in T:\n",
    "    ips.append(m.calc_implicit_parameters(i))\n",
    "ips = c14.tools.listofdict_to_dictofarray(ips)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "kappa24 = para['k24']\n",
    "kappa42 = para['k42']\n",
    "delta2 = para['d2n']\n",
    "delta4 = para['d4n']\n",
    "r2 = ips['b2n']\n",
    "r4 = ips['b4n']\n",
    "t=T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calc(i):\n",
    "    p = mm.parameters()\n",
    "    p.kappa24 = kappa24\n",
    "    p.kappa42 = kappa42\n",
    "    p.delta2 =  delta2\n",
    "    p.delta4 =  delta4\n",
    "    \n",
    "    \n",
    "\n",
    "    #time dependet parameteres list of doubles no extrapolations, just linear interpolation\n",
    "    p.lambda2_t.set(t,r2)\n",
    "    p.lambda4_t.set(t,r4)\n",
    "    #mm.test run sim(\n",
    "    # parameters ... mm.parameters() instance the parameter values\n",
    "    # delta_t    ... simulation time delta\n",
    "    # detlt_t_out .. write delta time\n",
    "    # max_t      ... max time of simulation\n",
    "    # seed\n",
    "    # n2         ... number of initial n2 cells\n",
    "    # n4         ... number of initial n4 cells\n",
    "    \n",
    "    #Paper Version\n",
    "    #res = mm.test(p,0.001,0.1,80,i,int(N0*ploidy(0) ),int(N0*(1-ploidy(0) )) )\n",
    "\n",
    "    #Fast Version\n",
    "    res = mm.test(p,0.001,0.1,80,i,int(N0i*m.ploidy(0) ),int(N0i*(1-m.ploidy(0) )) )\n",
    "    #output sort of vector [0] n2 cells; [1] n4 cells;\n",
    "    n2 = []\n",
    "    for i in res[0]:\n",
    "        n2.append(np.array(i))\n",
    "    n2 = np.array(n2)  \n",
    "    n4 = []\n",
    "    for i in res[1]:\n",
    "        n4.append(np.array(i))\n",
    "    n4 = np.array(n4)\n",
    "    #n2/n4[n,i] : number of cells with age i*delta_t_out at time n*delta_t_out\n",
    "    return n2,n4\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "\n",
    "#Paper Version\n",
    "#N0 = 1e6\n",
    "#Fast\n",
    "N0 = 1e6\n",
    "NUMP = 25\n",
    "N0i = N0/NUMP\n",
    "'''\n",
    "with Pool(14) as p:\n",
    "    xs = p.map(calc, range(NUMP))\n",
    "    \n",
    "    \n",
    "n2s = list()\n",
    "n4s = list()\n",
    "for i_n,i in enumerate(xs):\n",
    "    if i_n ==0:\n",
    "        n2s.append(i[0])    \n",
    "        n4s.append(i[1])\n",
    "    else:\n",
    "        n2s[0] = n2s[0] + i[0]\n",
    "        n4s[0] = n4s[0] + i[1]\n",
    "n2s = np.array(n2s)[0]\n",
    "n4s = np.array(n4s)[0]\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#np.save('Rm_newploidy.npy', np.array([n2s,n4s]) )\n",
    "N0 = 1e6\n",
    "n2s,n4s = np.load('Rm_newploidy.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dnatotal_to_N = N0*(m.ploidy(0)+2*(1-m.ploidy(0)))/float(lm.dnatotal_spline(0)[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(1)\n",
    "plt.plot(n2s[:-1,:].sum(axis=1))\n",
    "plt.figure(2)\n",
    "plt.plot(n4s[:-1,:].sum(axis=1))\n",
    "plt.figure(3)\n",
    "plt.plot(n2s[:-1,:].sum(axis=1)+2*n4s[:-1,:].sum(axis=1))\n",
    "plt.plot(10*t,lm.dnatotal_spline(t)[0]*dnatotal_to_N,'--')\n",
    "plt.figure(4)\n",
    "plt.plot(10*t,m.ploidy(t),'--')\n",
    "plt.plot(n2s[:-1,:].sum(axis=1)/(n2s[:-1,:].sum(axis=1)+n4s[:-1,:].sum(axis=1)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rdf = pd.DataFrame(n2s)\n",
    "rdf.columns.name = 'cell_age'\n",
    "rdf.index.name = 'subject_age'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rdf4 = pd.DataFrame(n4s)\n",
    "rdf4.columns.name = 'cell_age'\n",
    "rdf4.index.name = 'subject_age'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = rdf.unstack()\n",
    "df.name = 'cell_number'\n",
    "df = df.reset_index()\n",
    "\n",
    "df['cell_birth'] = df['subject_age'] - df['cell_age']\n",
    "\n",
    "df = df.query(\"cell_birth >= 0\")[['subject_age', 'cell_number', 'cell_birth']].pivot(index='cell_birth', columns='subject_age')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df4 = rdf4.unstack()\n",
    "df4.name = 'cell_number'\n",
    "df4 = df4.reset_index()\n",
    "\n",
    "df4['cell_birth'] = df4['subject_age'] - df4['cell_age']\n",
    "\n",
    "df4 = df4.query(\"cell_birth >= 0\")[['subject_age', 'cell_number', 'cell_birth']].pivot(index='cell_birth', columns='subject_age')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "decades = np.arange(800, -1, -100)\n",
    "colors = [(v, v, v) for v in np.linspace(0.1, 0.9, len(decades))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.set_context('talk')\n",
    "sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10,5))\n",
    "for i, color in zip(decades, colors):\n",
    "    l = plt.fill_between(df.columns.levels[1]/10, df.loc[0:i].sum()/(df.sum()+df4.sum()), color=color,lw=0)\n",
    "    plt.fill_between(df4.columns.levels[1]/10,\n",
    "                     df.sum()/(df.sum()+df4.sum()),\n",
    "                     df.sum()/(df.sum()+df4.sum())+df4.loc[0:i].sum()/(df.sum()+df4.sum()),\n",
    "                     color=l.get_facecolor(),\n",
    "                     label=f'{i/10:.0f}',lw=0)\n",
    "#     plt.plot(df4.columns.levels[1], df.sum()/(df.sum()+df4.sum())+df4.loc[0:i].sum()/(df.sum()+df4.sum()))\n",
    "plt.legend(loc=\"upper left\", bbox_to_anchor=(1.1, 1.1), title='birth decade')\n",
    "plt.xlabel('subject age / years')\n",
    "plt.ylabel('fraction')\n",
    "plt.text(35, 0.4, '2n')\n",
    "plt.text(35, 0.9, '4n')\n",
    "#plt.xlim(0, 80)\n",
    "plt.ylim(0, 1)\n",
    "plt.xlim(0,80)\n",
    "plt.tight_layout()\n",
    "plt.savefig('./age_distributionR_newploidy.pdf', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ages = np.array(rdf.columns)/10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def aage(page,f,rate):\n",
    "    return page*(1-f)+(1-np.exp(-page*rate*2))/(2*rate)*f\n",
    "#plt.plot(t,aage(t,1,df_imp.loc[idx[:,'r2']].values))\n",
    "#plt.plot(t,aage(t,1,df_imp.loc[idx[:,'r2']].values))\n",
    "a=1\n",
    "x=(rdf.index/10)\n",
    "total = (rdf+rdf4)\n",
    "y = ( (rdf.T/rdf.sum(axis=1)).T *rdf.columns/10).sum(axis=1)\n",
    "y2= ( (rdf4.T/rdf4.sum(axis=1)).T *rdf4.columns/10).sum(axis=1)\n",
    "y3 = ((total.T/total.sum(axis=1)).T *total.columns/10).sum(axis=1)\n",
    "plt.plot(x,y,label='2n')\n",
    "plt.plot(x,y2,label='pn')\n",
    "plt.plot(x,y3,label='all' )\n",
    "plt.legend()\n",
    "\n",
    "plt.savefig('Ravgerage_age_newploidy.pdf')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.DataFrame(np.array([y,y2,y3]).T,index=x,columns=['2n','4n','both'])\n",
    "data.to_excel('average_cell_age_newploidy.xlsx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i=500\n",
    "np.sum(rdf.loc[i]/rdf.loc[i].sum()*rdf.columns/10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i=500\n",
    "np.sum(rdf4.loc[i]/rdf4.loc[i].sum()*rdf4.columns/10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rdf.loc[i]/rdf.loc[i].sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in [250,500,750]:\n",
    "    y4 = rdf4.loc[i]/rdf4.loc[i].sum()\n",
    "    print('Alter',i//10,' Wert',y4.loc[100:].sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "total = rdf+rdf4\n",
    "for i in [20,250,500,750]:\n",
    "    ptotal = total.loc[i]/total.loc[i].sum()\n",
    "    print('Alter',i//10,' Wert',ptotal.loc[:20].sum())\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "total = rdf\n",
    "for i in [20,250,500,750]:\n",
    "    ptotal = total.loc[i]/total.loc[i].sum()\n",
    "    print('Alter',i//10,' Wert',ptotal.loc[:20].sum())\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "\n",
    "n2p = []\n",
    "n4p = []\n",
    "bp =[]\n",
    "\n",
    "for i in [250,500,750]:\n",
    "\n",
    "    y = rdf.loc[i]/rdf.loc[i].sum()\n",
    "    y4 = rdf4.loc[i]/rdf4.loc[i].sum()\n",
    "    yb = rdf.loc[i]+rdf4.loc[i]\n",
    "    yb = yb/yb.sum()\n",
    "    \n",
    "    tt =[]\n",
    "    xx=np.arange(0,1,0.1)\n",
    "    for p in xx:\n",
    "        try:\n",
    "            tt.append(ages[np.cumsum(y)<p][-1]+0.1)\n",
    "        except IndexError:\n",
    "            tt.append(0.0+0.1)\n",
    "    n2p.append(pd.Series(tt,index=pd.Index(xx,name='percetile'),name=i/10))\n",
    "    \n",
    "    tt =[]\n",
    "    xx=np.arange(0,1,0.1)\n",
    "    for p in xx:\n",
    "        try:\n",
    "            tt.append(ages[np.cumsum(y4)<p][-1]+0.1)\n",
    "        except IndexError:\n",
    "            tt.append(0.0+0.1)\n",
    "    n4p.append(pd.Series(tt,index=pd.Index(xx,name='percetile'),name=i/10))\n",
    "    \n",
    "    tt =[]\n",
    "    xx=np.arange(0,1,0.1)\n",
    "    for p in xx:\n",
    "        try:\n",
    "            tt.append(ages[np.cumsum(yb)<p][-1]+0.1)\n",
    "        except IndexError:\n",
    "            tt.append(0.0+0.1)\n",
    "    bp.append(pd.Series(tt,index=pd.Index(xx,name='percetile'),name=i/10))\n",
    "    \n",
    "    \n",
    "    \n",
    "\n",
    "n2p=pd.concat(n2p,axis=1)\n",
    "n4p=pd.concat(n4p,axis=1)\n",
    "bp=pd.concat(bp,axis=1)\n",
    "\n",
    "tttidx=pd.Index(np.arange(0,80.1,0.1),name='person age')\n",
    "n2ttt = pd.Series(np.diag(rdf.values/rdf.values.sum(axis=1)),index=tttidx,name='2n')\n",
    "n4ttt = pd.Series(np.diag(rdf4.values/rdf4.values.sum(axis=1)),index=tttidx,name='4n')\n",
    "bb = rdf4 + rdf\n",
    "nbttt = pd.Series(np.diag(bb.values/bb.values.sum(axis=1)),index=tttidx,name='both')\n",
    "ages_b=pd.concat([n2ttt,n4ttt,nbttt],axis=1)\n",
    "\n",
    "excel_writer = pd.ExcelWriter('agesR_newploidy.xlsx')\n",
    "n2p.to_excel(excel_writer=excel_writer,sheet_name='n2')\n",
    "n4p.to_excel(excel_writer=excel_writer,sheet_name='n4')\n",
    "bp.to_excel(excel_writer=excel_writer,sheet_name='both')\n",
    "ages_b.to_excel(excel_writer=excel_writer,sheet_name='ages')\n",
    "excel_writer.save()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f=plt.figure()\n",
    "N=10\n",
    "s=(N,1)\n",
    "top = 3\n",
    "ax =  plt.subplot2grid(s,(0,0),rowspan=top)\n",
    "ax2 = plt.subplot2grid(s,(top,0),rowspan=N-top)\n",
    "\n",
    "ax.set_ylim(10,65)\n",
    "ax2.set_ylim(0,10)\n",
    "\n",
    "\n",
    "#insgesammt auf eins normiert\n",
    "xx = np.array([250,500,750])\n",
    "d=0.2\n",
    "d2=0\n",
    "for i_n,i in enumerate(xx):\n",
    "    cellhist = rdf.loc[i]/rdf.loc[i].sum()\n",
    "    y = cellhist[cellhist!=0]\n",
    "    x = ages[cellhist!=0]\n",
    "    \n",
    "    cellhist = rdf4.loc[i]/rdf4.loc[i].sum()\n",
    "    y4 = cellhist[cellhist!=0]\n",
    "    x4 = ages[cellhist!=0]\n",
    "    \n",
    "    ax.fill_betweenx(x,  -y+i_n*d-d2  ,   i_n*d-d2,   color='gray',label='2n',lw=0.5,fc='gray')\n",
    "    ax.fill_betweenx(x4,    i_n*d+d2 , y4+i_n*d+d2,     color='black',label='pn',lw=0.5,fc='black')\n",
    "    ax2.fill_betweenx(x,  -y+i_n*d-d2  ,   i_n*d-d2,   color='gray',label='2n',lw=0.5,fc='gray')\n",
    "    ax2.fill_betweenx(x4,    i_n*d+d2 , y4+i_n*d+d2,     color='black',label='pn',lw=0.5,fc='black')\n",
    "\n",
    "ax2.set_xticks(np.arange(len(xx))*d)\n",
    "ax2.set_xticklabels((xx/10).astype(int))\n",
    "#ax2.set_xticklabels([''])\n",
    "ax2.set_yticks([0,2,4,6,8])\n",
    "\n",
    "ax.set_yticks([20,60])\n",
    "\n",
    "# hide the spines between ax and ax2\n",
    "ax.spines['bottom'].set_visible(False)\n",
    "ax2.spines['top'].set_visible(False)\n",
    "ax.tick_params(labelbottom='off')\n",
    "ax.set_xticks([])\n",
    "\n",
    "f.text(0.00, 0.5, 'cell age / years', va='center', rotation='vertical')\n",
    "ax2.set_xlabel('subject age / years')\n",
    "\n",
    "\n",
    "plt.subplots_adjust(hspace=0.1)\n",
    "handles, labels = ax.get_legend_handles_labels()\n",
    "ax.legend(handles[:2], labels[:2],loc=\"upper left\")\n",
    "d = .015 # how big to make the diagonal lines in axes coordinates\n",
    "e = 0.02\n",
    "kwargs = dict(transform=ax2.transAxes, color='k', clip_on=False)\n",
    "ax2.plot((-d,+d), (1-d+e,1+d+e), **kwargs)\n",
    "ax2.plot((1-d,1+d), (1-d+e,1+d+e), **kwargs)\n",
    "ax2.plot((-d,+d), (1-d,1+d), **kwargs)\n",
    "ax2.plot((1-d,1+d), (1-d,1+d), **kwargs)\n",
    "plt.savefig('./Rm_age_violinplot_normed_newploidy.pdf', bbox_inches='tight')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f=plt.figure()\n",
    "N=10\n",
    "s=(N,1)\n",
    "top = 3\n",
    "ax =  plt.subplot2grid(s,(0,0),rowspan=top)\n",
    "ax2 = plt.subplot2grid(s,(top,0),rowspan=N-top)\n",
    "\n",
    "ax.set_ylim(10,65)\n",
    "ax2.set_ylim(0,10)\n",
    "#split axes n lower upper\n",
    "xx = np.array([200])\n",
    "\n",
    "#for Paper\n",
    "#d=3e6\n",
    "#d2=1e4\n",
    "\n",
    "d2=0.00\n",
    "\n",
    "#for i_n,i in enumerate(xx):\n",
    "i=250\n",
    "cell_hist=np.array([a for a in rdf.loc[i]+rdf4.loc[i] ])/(rdf.loc[i]+rdf4.loc[i]).sum()\n",
    "y = cell_hist[cell_hist!=0]\n",
    "x = ages[cell_hist!=0]\n",
    "print(x[-1])\n",
    "i=750\n",
    "cell_hist=np.array([a for a in rdf.loc[i]+rdf4.loc[i] ])/(rdf.loc[i]+rdf4.loc[i]).sum()\n",
    "y4 = cell_hist[cell_hist!=0]\n",
    "x4 = ages[cell_hist!=0]\n",
    "print(x4[-1])\n",
    "\n",
    "ax2.fill_betweenx(x,  -y-d2  ,   -d2,   color='gray',label='25',lw=0.5,fc='gray')\n",
    "ax2.fill_betweenx(x4,    d2 , y4+d2,     color='black',label='75',lw=0.5,fc='black')\n",
    "\n",
    "ax.fill_betweenx(x,  -y-d2  ,   -d2,   color='gray',label='25',lw=0.5,fc='gray')\n",
    "ax.fill_betweenx(x4,   +d2 , y4+d2,     color='black',label='75',lw=0.5,fc='black')\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "ax2.set_yticks([0,2,4,6,8])\n",
    "\n",
    "ax.set_yticks([20,60])\n",
    "\n",
    "# hide the spines between ax and ax2\n",
    "ax.spines['bottom'].set_visible(False)\n",
    "ax2.spines['top'].set_visible(False)\n",
    "ax.tick_params(labelbottom='off')\n",
    "ax.set_xticks([])\n",
    "\n",
    "f.text(0.00, 0.5, 'cell age / years', va='center', rotation='vertical')\n",
    "ax2.set_xlabel('')\n",
    "ax2.set_xticks([])\n",
    "\n",
    "\n",
    "plt.subplots_adjust(hspace=0.1)\n",
    "handles, labels = ax.get_legend_handles_labels()\n",
    "ax.legend(handles[:2], labels[:2],loc=\"upper left\")\n",
    "d = .015 # how big to make the diagonal lines in axes coordinates\n",
    "e = 0.02\n",
    "kwargs = dict(transform=ax2.transAxes, color='k', clip_on=False)\n",
    "ax2.plot((-d,+d), (1-d+e,1+d+e), **kwargs)\n",
    "ax2.plot((1-d,1+d), (1-d+e,1+d+e), **kwargs)\n",
    "ax2.plot((-d,+d), (1-d,1+d), **kwargs)\n",
    "ax2.plot((1-d,1+d), (1-d,1+d), **kwargs)\n",
    "\n",
    "\n",
    "ax.set_xlim(ax.get_xlim()[0],-ax.get_xlim()[0])\n",
    "ax2.set_xlim(ax2.get_xlim()[0],-ax2.get_xlim()[0])\n",
    "\n",
    "plt.savefig('./Rm_age_violinplot_ages_all_newploidy.pdf', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "c14",
   "language": "python",
   "name": "c14"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": "block",
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}