{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "822259e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from matplotlib import pyplot as plt\n",
    "from scipy.stats import bayes_mvs as bayesest\n",
    "import time\n",
    "from tqdm import tqdm\n",
    "\n",
    "from PyEcoLib.simulator import Simulator\n",
    "import matplotlib.gridspec as gridspec\n",
    "import matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc57a0e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "mean_size = 1  # femto liter\n",
    "doubling_time = 1  # min\n",
    "tmax: int = 6  # min\n",
    "sample_time = 0.05  # min\n",
    "div_steps = 20\n",
    "ncells: int = 1000\n",
    "gr=np.log(2)\n",
    "sample_time=0.05\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6dc0fe7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def setaxis(ax):\n",
    "    for axis in ['bottom','left']:\n",
    "        ax.spines[axis].set_linewidth(1.5)\n",
    "    for axis in ['top','right']:\n",
    "        ax.spines[axis].set_linewidth(0)\n",
    "    ax.grid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00f86716",
   "metadata": {},
   "outputs": [],
   "source": [
    "gr = np.log(2)/doubling_time\n",
    "\n",
    "if not os.path.exists('./data'):\n",
    "    os.makedirs('./data')  # data path\n",
    "if not os.path.exists('./figures'):\n",
    "    os.makedirs('./figures')  # Figures path\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f5dd210",
   "metadata": {},
   "source": [
    "SINGLE CELL SIMULATION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef4db6e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Simulating some cell size trajectories\n",
    "from PyEcoLib.simulator import Simulator\n",
    "sim = Simulator(ncells=ncells, gr=gr, sb=mean_size, steps=div_steps,V0array=np.random.gamma(shape=1/0.02,scale=0.02,size=1000)) \n",
    "sim.szdyn(tmax=5, sample_time=0.01, nameCRM='./data/SingleLin.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c9165d9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "#function to bin the data for division strategy\n",
    "def getbins(x,y,qnt):\n",
    "    \n",
    "    df=pd.DataFrame({'X':x,'Y':y})\n",
    "    quantnumber=qnt\n",
    "\n",
    "    CV2d=[]\n",
    "    delt=[]\n",
    "    sb=[]\n",
    "\n",
    "    errcv2d=[]\n",
    "    errdelt=[]\n",
    "    errsb=[]\n",
    "    bins=np.linspace(np.min(x),np.max(x),qnt+1)\n",
    "    for i in range(len(bins)-1):\n",
    "        quanta1=df[df.X>bins[i]]\n",
    "        quanta2=quanta1[quanta1.X<bins[i+1]] \n",
    "        mean_cntr, var_cntr, std_cntr = bayesest(quanta2.Y,alpha=0.95)\n",
    "        meanv0_cntr, varv0_cntr, stdv0_cntr = bayesest(quanta2.X,alpha=0.95)\n",
    "        CV2d.append(var_cntr[0]/mean_cntr[0]**2)\n",
    "        delt.append(mean_cntr[0])\n",
    "        sb.append(meanv0_cntr[0])\n",
    "        errv=(var_cntr[1][1]-var_cntr[0])/mean_cntr[0]**2+2*(mean_cntr[1][1]-mean_cntr[0])*var_cntr[0]/mean_cntr[0]**3\n",
    "        errcv2d.append(errv)\n",
    "        errdelt.append(mean_cntr[1][1]-mean_cntr[0])\n",
    "        errsb.append(meanv0_cntr[1][1]-meanv0_cntr[0])\n",
    "    return (sb,errsb,delt,errdelt)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb96f308",
   "metadata": {},
   "outputs": [],
   "source": [
    "sim.divstrat(tmax=10, nameDSM = \"./data/dataDSM.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f6d1d5fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Ploting Figure1\n",
    "fig= plt.figure(figsize=(15,2.5))\n",
    "gs0 = gridspec.GridSpec(1, 3, figure=fig,wspace=0.2,hspace=0.2)\n",
    "\n",
    "\n",
    "ax1 = fig.add_subplot(gs0[1])\n",
    "data=pd.read_csv('./data/SingleLin.csv')\n",
    "for c in data.columns[10:19]:\n",
    "    df=data[c]\n",
    "    ax1.plot(np.linspace(0,5,len(df)),df,c='#bebebe')\n",
    "\n",
    "df=data[data.columns[7]]\n",
    "ax1.plot(np.linspace(0,5,len(df)),df,lw=2)\n",
    "ax1.set_ylim(0,3)\n",
    "ax1.set_xlim(0,5)\n",
    "gs00 = gridspec.GridSpecFromSubplotSpec(1,2, subplot_spec=gs0[2],hspace=0.1)\n",
    "ax20 = fig.add_subplot(gs00[0])\n",
    "\n",
    "df=pd.read_csv(\"./data/dataDSM.csv\")\n",
    "ax20.set_ylim(0.2,2.2)\n",
    "ax20.set_xlim(0.2,2.2)\n",
    "added=np.random.gamma(shape=20,scale=1/20,size=1000)\n",
    "ax20.scatter(df.S_b.tolist()[:1000],added,s=1,c='#0192EA')\n",
    "\n",
    "sb,errsb,delt,errdelt=getbins(df.S_b.tolist()[:1000],added,qnt=5)\n",
    "\n",
    "plt.plot([np.min(df.S_b),np.max(df.S_b)],[1,1],c='#02447E')\n",
    "\n",
    "ax20.errorbar(np.array(sb),np.array(delt),xerr=errsb,yerr=errdelt, fmt='o',\n",
    "                 mec='#02447E',capsize=5,markersize='5',elinewidth=3,c='#0073B9')\n",
    "\n",
    "ax20.set_ylabel('Added Size')\n",
    "ax20.set_xlabel('Size at Birth')\n",
    "setaxis(ax20)\n",
    "setaxis(ax1)\n",
    "ax1.set_xlabel('Time')\n",
    "ax1.set_ylabel('Cell Size')\n",
    "\n",
    "data=pd.read_csv('./data/SingleLin.csv')\n",
    "mnarr=[]\n",
    "for t in data.time.unique():\n",
    "    datatime=data[data.time==t]\n",
    "    dataszs=datatime[datatime.columns[1:]]\n",
    "    mnarr.append(np.mean(dataszs.iloc[0].tolist()))\n",
    "ax1.plot(data.time.unique(),mnarr,c=\"#696969\")\n",
    "\n",
    "plt.savefig('./SizeDyn.eps',bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36879eeb",
   "metadata": {},
   "source": [
    "POPULATION SIMULATION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "804a58a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "#population simulator\n",
    "from PyEcoLib.PopSimulator import PopSimulator\n",
    "sim = PopSimulator(ncells=500, gr=np.log(2), sb=1, steps=10, nu=2,\n",
    "                   CV2gr=0.002,CV2div=0.001,V0array=np.random.gamma(shape=1/0.03,scale=0.03,size=500)) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91fd4516",
   "metadata": {},
   "outputs": [],
   "source": [
    "sim.szdyn(tmax=4, sample_time=0.01, FileName='./data/dynamics.csv', DivEventsFile='./data/divevents.csv')\n",
    "pd.read_csv('./data/dynamics.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9bf6eb58",
   "metadata": {},
   "outputs": [],
   "source": [
    "#ploting Figure3\n",
    "fig= plt.figure(figsize=(17,2.5))\n",
    "gs0 = gridspec.GridSpec(1, 3, figure=fig,wspace=0.2,hspace=0.2)\n",
    "gs00 = gridspec.GridSpecFromSubplotSpec(1,2, subplot_spec=gs0[0],hspace=0.1)\n",
    "ax10 = fig.add_subplot(gs00[1])\n",
    "ax0 = fig.add_subplot(gs0[1])\n",
    "data=pd.read_csv('./data/dynamics.csv')\n",
    "data1=data[data.Sample==105]\n",
    "for cell in data1.Cell.unique():\n",
    "    datacell=data1[data1.Cell==cell]\n",
    "    ax0.plot(datacell.Time,datacell.Size)    \n",
    "\n",
    "gs00 = gridspec.GridSpecFromSubplotSpec(1,2, subplot_spec=gs0[2],hspace=0.1)\n",
    "ax20 = fig.add_subplot(gs00[0])\n",
    "\n",
    "data=pd.read_csv('./data/dynamics.csv')\n",
    "\n",
    "for sample in data.Sample.unique()[1:20]:\n",
    "    data1=data[data.Sample==sample]\n",
    "    Narr=[]\n",
    "    for time in data1.Time.unique():\n",
    " \n",
    "        datatime=data1[data1.Time==time]\n",
    "        Narr.append(len(datatime))\n",
    "    ax20.plot(data1.Time.unique(),Narr,c='#bebebe')\n",
    "    \n",
    "data1=data[data.Sample==105]\n",
    "Narr=[]\n",
    "for time in data1.Time.unique():\n",
    "\n",
    "    datatime=data1[data1.Time==time]\n",
    "    Narr.append(len(datatime))\n",
    "ax20.plot(data1.Time.unique(),Narr)\n",
    "    \n",
    "ax20.set_yscale('log')\n",
    "\n",
    "Narr=[]\n",
    "for time in data.Time.unique():\n",
    "    \n",
    "    datatime=data[data.Time==time]\n",
    "    Nsample=[]\n",
    "    for sample in datatime.Sample.unique():\n",
    "        datas=datatime[datatime.Sample==sample]\n",
    "        Nsample.append(len(datas))\n",
    "        \n",
    "    Narr.append(np.mean(Nsample))\n",
    "ax20.plot(data1.Time.unique(),smoot(Narr,5),c='#696969')\n",
    "\n",
    "Narr=[]\n",
    "for time in data.Time.unique():\n",
    "    \n",
    "    datatime=data[data.Time==time]\n",
    "\n",
    "        \n",
    "    Narr.append(np.mean(datatime.Size))\n",
    "ax0.plot(smoot(data1.Time.unique(),3),Narr,c='#696969')\n",
    "\n",
    "ax20.set_ylabel('Cell Population')\n",
    "ax20.set_xlabel('Time')\n",
    "setaxis(ax20)\n",
    "setaxis(ax0)\n",
    "ax0.set_xlabel('Time')\n",
    "ax0.set_xlim(0,4)\n",
    "ax0.set_ylim(0,2.5)\n",
    "ax1.set_xlim(0,3)\n",
    "ax0.set_ylabel('Cell Size')\n",
    "plt.savefig('./PopDyn.eps',bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e762d16d",
   "metadata": {},
   "outputs": [],
   "source": [
    "CV2sz = 0.02\n",
    "tmax=6\n",
    "sim = Simulator(ncells=1, gr=gr, sb=mean_size, steps=div_steps,lamb=0.5)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f1b4aaa",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Numerical solution for the cell size moments dynamics (adder, sizer and timer)\n",
    "sim = Simulator(ncells=1, gr=gr, sb=mean_size, steps=div_steps,lamb=1)\n",
    "sim.szdynFSP(tmax=tmax,sample_time=0.05, nameFSP=\"./data/AdderDyn.csv\", CV2sz=CV2sz)\n",
    "\n",
    "sim = Simulator(ncells=1, gr=gr, sb=mean_size, steps=div_steps,lamb=1)\n",
    "sim.szdynFSP(tmax=tmax,sample_time=0.05, nameFSP=\"./data/dataFSPsz.csv\", CV2sz=CV2sz)\n",
    "\n",
    "sim = Simulator(ncells=1, gr=gr, sb=mean_size, steps=div_steps,lamb=0.5)\n",
    "sim.szdynFSP(tmax=tmax,sample_time=0.05, nameFSP=\"./data/dataFSPtim.csv\", CV2sz=CV2sz)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01fba4ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Simulation of the division strategy (adder, sizer and timer)\n",
    "\n",
    "tmax=10\n",
    "ncells=5000\n",
    "start = time.time()\n",
    "sim = Simulator(ncells=ncells, gr=gr, sb=mean_size, steps=div_steps)\n",
    "sim.divstrat(tmax=tmax,  nameDSM=\"./data/dataDSMadder.csv\")\n",
    "print('It took', np.int(time.time()-start), 'seconds.')\n",
    "\n",
    "ncells=5000\n",
    "start = time.time()\n",
    "sim = Simulator(ncells=ncells, gr=gr, sb=mean_size, steps=div_steps, lamb=2)\n",
    "sim.divstrat(tmax=tmax, nameDSM=\"./data/dataDSMsizer.csv\")\n",
    "print('It took', np.int(time.time()-start), 'seconds.')\n",
    "\n",
    "start = time.time()\n",
    "ncells=10000\n",
    "sim = Simulator(ncells=ncells, gr=gr, sb=mean_size, steps=div_steps, lamb=0.5)\n",
    "sim.divstrat(tmax=tmax, nameDSM=\"./data/dataDSMtimer.csv\")\n",
    "print('It took', np.int(time.time()-start), 'seconds.')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "103eb079",
   "metadata": {},
   "outputs": [],
   "source": [
    "data2 = pd.read_csv(\"./data/dataDSMadder.csv\")\n",
    "data2 = data2[data2.time > 5*doubling_time]\n",
    "\n",
    "quantnumber = 5\n",
    "pvadd2 = data2\n",
    "\n",
    "CV2darr1 = []\n",
    "deltarr1 = []\n",
    "sbarr1 = []\n",
    "\n",
    "errcv2darr1 = []\n",
    "errdeltarr1 = []\n",
    "errsbarr1 = []\n",
    "for i in range(quantnumber):\n",
    "    lperv0 = np.percentile(pvadd2.S_b, i*100/quantnumber)\n",
    "    hperv0 = np.percentile(pvadd2.S_b, (i+1)*100/quantnumber)\n",
    "    quanta1 = pvadd2[pvadd2.S_b > lperv0]\n",
    "    quanta2 = quanta1[quanta1.S_b < hperv0]\n",
    "    mean_cntr, var_cntr, std_cntr = bayesest((quanta2.S_d-quanta2.S_b)/np.mean(pvadd2.S_d-pvadd2.S_b), alpha=0.95)\n",
    "    meanv0_cntr, varv0_cntr, stdv0_cntr = bayesest(quanta2.S_b/np.mean(pvadd2.S_b), alpha=0.95)\n",
    "    CV2darr1.append(var_cntr[0]/mean_cntr[0]**2)\n",
    "    deltarr1.append(mean_cntr[0])\n",
    "    sbarr1.append(meanv0_cntr[0])\n",
    "    errv = (var_cntr[1][1]-var_cntr[0])/mean_cntr[0]**2+2*(mean_cntr[1][1]-mean_cntr[0])*var_cntr[0]/mean_cntr[0]**3\n",
    "    errcv2darr1.append(errv)\n",
    "    errdeltarr1.append(mean_cntr[1][1]-mean_cntr[0])\n",
    "    errsbarr1.append(meanv0_cntr[1][1]-meanv0_cntr[0])\n",
    "\n",
    "data3 = pd.read_csv(\"./data/dataDSMsizer.csv\")\n",
    "data3 = data3[data3.time>5*doubling_time]\n",
    "\n",
    "quantnumber = 5\n",
    "pvadd2 = data3\n",
    "\n",
    "CV2darr2 = []\n",
    "deltarr2 = []\n",
    "sbarr2 = []\n",
    "\n",
    "errcv2darr2 = []\n",
    "errdeltarr2 = []\n",
    "errsbarr2 = []\n",
    "for i in range(quantnumber):\n",
    "    lperv0 = np.percentile(pvadd2.S_b, i*100/quantnumber)\n",
    "    hperv0 = np.percentile(pvadd2.S_b, (i+1)*100/quantnumber)\n",
    "    quanta1 = pvadd2[pvadd2.S_b > lperv0]\n",
    "    quanta2 = quanta1[quanta1.S_b < hperv0]\n",
    "    mean_cntr, var_cntr, std_cntr = bayesest((quanta2.S_d-quanta2.S_b)/np.mean(pvadd2.S_d-pvadd2.S_b), alpha=0.95)\n",
    "    meanv0_cntr, varv0_cntr, stdv0_cntr = bayesest(quanta2.S_b/np.mean(pvadd2.S_b), alpha=0.95)\n",
    "    CV2darr2.append(var_cntr[0]/mean_cntr[0]**2)\n",
    "    deltarr2.append(mean_cntr[0])\n",
    "    sbarr2.append(meanv0_cntr[0])\n",
    "    errv = (var_cntr[1][1]-var_cntr[0])/mean_cntr[0]**2+2*(mean_cntr[1][1]-mean_cntr[0])*var_cntr[0]/mean_cntr[0]**3\n",
    "    errcv2darr2.append(errv)\n",
    "    errdeltarr2.append(mean_cntr[1][1]-mean_cntr[0])\n",
    "    errsbarr2.append(meanv0_cntr[1][1]-meanv0_cntr[0])\n",
    "\n",
    "data4 = pd.read_csv(\"./data/dataDSMtimer.csv\")\n",
    "data4 = data4[data4.time>5*doubling_time]\n",
    "\n",
    "quantnumber = 5\n",
    "pvadd2 = data4\n",
    "\n",
    "CV2darr3 = []\n",
    "deltarr3 = []\n",
    "sbarr3 = []\n",
    "\n",
    "errcv2darr3 = []\n",
    "errdeltarr3 = []\n",
    "errsbarr3 = []\n",
    "for i in range(quantnumber):\n",
    "    lperv0 = np.percentile(pvadd2.S_b,i*100/quantnumber)\n",
    "    hperv0 = np.percentile(pvadd2.S_b,(i+1)*100/quantnumber)\n",
    "    quanta1 = pvadd2[pvadd2.S_b>lperv0]\n",
    "    quanta2 = quanta1[quanta1.S_b<hperv0]\n",
    "    mean_cntr, var_cntr, std_cntr = bayesest((quanta2.S_d-quanta2.S_b)/np.mean(pvadd2.S_d-pvadd2.S_b), alpha=0.95)\n",
    "    meanv0_cntr, varv0_cntr, stdv0_cntr = bayesest(quanta2.S_b/np.mean(pvadd2.S_b), alpha=0.95)\n",
    "    CV2darr3.append(var_cntr[0]/mean_cntr[0]**2)\n",
    "    deltarr3.append(mean_cntr[0])\n",
    "    sbarr3.append(meanv0_cntr[0])\n",
    "    errv = (var_cntr[1][1]-var_cntr[0])/mean_cntr[0]**2+2*(mean_cntr[1][1]-mean_cntr[0])*var_cntr[0]/mean_cntr[0]**3\n",
    "    errcv2darr3.append(errv)\n",
    "    errdeltarr3.append(mean_cntr[1][1]-mean_cntr[0])\n",
    "    errsbarr3.append(meanv0_cntr[1][1]-meanv0_cntr[0])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b91f9f57",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Numerical estimation of the mean trends for the division strategy\n",
    "\n",
    "sim = Simulator(ncells=1, gr=gr, sb=mean_size, steps=div_steps, lamb=0.5)\n",
    "sbar = np.linspace(0.5, 1.5, 100)*mean_size\n",
    "cv2tim = []\n",
    "delttim = []\n",
    "for i in sbar:\n",
    "    sd, cv2 = sim.SdStat(i)\n",
    "    cv2tim.append(cv2)\n",
    "    delttim.append(sd)\n",
    "\n",
    "\n",
    "sim = Simulator(ncells=1, gr=gr, sb=mean_size, steps=div_steps)\n",
    "sbar = np.linspace(0.5, 1.5, 100)*mean_size\n",
    "cv2ad = []\n",
    "deltad = []\n",
    "for i in sbar:\n",
    "    sd, cv2 = sim.SdStat(i)\n",
    "    cv2ad.append(cv2)\n",
    "    deltad.append(sd)\n",
    "\n",
    "\n",
    "sim = Simulator(ncells=1, gr = gr, sb=mean_size, steps = div_steps,lamb=2)\n",
    "sbar = np.linspace(0.5,1.5,100)*mean_size\n",
    "cv2sz = []\n",
    "deltsz = []\n",
    "for i in sbar:\n",
    "    sd, cv2 = sim.SdStat(i)\n",
    "    cv2sz.append(cv2)\n",
    "    deltsz.append(sd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c766af1",
   "metadata": {},
   "outputs": [],
   "source": [
    "#ploting division strategy\n",
    "fig, ax = plt.subplots(1, 2, figsize=(12, 4))\n",
    "\n",
    "ax[0].errorbar(np.array(sbarr1), np.array(deltarr1), xerr=errsbarr1, yerr=errdeltarr1, fmt='o', mec='k', capsize=5,\n",
    "               markersize='8', elinewidth=3, c='k')\n",
    "ax[1].errorbar(np.array(sbarr1), CV2darr1, xerr=errsbarr1, yerr=errcv2darr1, fmt='o', mec='k', capsize=5,\n",
    "               markersize='8', elinewidth=3, c='k')\n",
    "\n",
    "ax[0].errorbar(np.array(sbarr2), np.array(deltarr2), xerr=errsbarr2, yerr=errdeltarr2, fmt='o', mec='k', capsize=5,\n",
    "               markersize='8', elinewidth=3, c='r')\n",
    "ax[1].errorbar(np.array(sbarr2), CV2darr2, xerr=errsbarr2, yerr=errcv2darr2, fmt='o', mec='k', capsize=5,\n",
    "               markersize='8', elinewidth=3, c='r')\n",
    "\n",
    "ax[0].errorbar(np.array(sbarr3), np.array(deltarr3), xerr=errsbarr3, yerr=errdeltarr3, fmt='o', mec='k', capsize=5,\n",
    "               markersize='8', elinewidth=3, c='g')\n",
    "ax[1].errorbar(np.array(sbarr3), CV2darr3, xerr=errsbarr3, yerr=errcv2darr3, fmt='o', mec='k', capsize=5,\n",
    "               markersize='8', elinewidth=3, c='g')\n",
    "\n",
    "\n",
    "ax[1].set_ylim([0, 0.3])\n",
    "\n",
    "ax[0].set_xlabel(\"$s_b/\\overline{s_b}$\", size=20)\n",
    "ax[1].set_xlabel(\"$s_b/\\overline{s_b}$\", size=20)\n",
    "ax[0].set_ylabel(\"$\\Delta/\\overline{s_b}$\", size=15)\n",
    "ax[1].set_ylabel(\"$C_V^2(\\Delta)$\", size=15)\n",
    "for l in [0, 1]:\n",
    "    ax[l].grid()\n",
    "    ax[l].tick_params(axis='x', labelsize=15)\n",
    "    ax[l].tick_params(axis='y', labelsize=15)\n",
    "    for axis in ['bottom', 'left']:\n",
    "        ax[l].spines[axis].set_linewidth(2)\n",
    "        ax[l].tick_params(axis='both', width=2, length=6)\n",
    "    for axis in ['top', 'right']:\n",
    "        ax[l].spines[axis].set_linewidth(0)\n",
    "        ax[l].tick_params(axis='both', width=0, length=6)\n",
    "\n",
    "\n",
    "ax[0].plot(np.array(sbar)/mean_size, np.array(delttim)/mean_size, lw=2,c='g', label=\"$\\lambda=0.5$\")\n",
    "ax[1].plot(np.array(sbar)/mean_size, cv2tim, lw=2, c='g')\n",
    "\n",
    "ax[0].plot(np.array(sbar)/mean_size, np.array(deltad)/mean_size, lw=2, c='k', label=\"$\\lambda=1$\")\n",
    "ax[1].plot(np.array(sbar)/mean_size, cv2ad, lw=2, c='k')\n",
    "\n",
    "ax[0].plot(np.array(sbar)/mean_size, np.array(deltsz)/mean_size, lw=2, c='r', label=\"$\\lambda=2$\")\n",
    "ax[1].plot(np.array(sbar)/mean_size, cv2sz, lw=2, c='r')\n",
    "\n",
    "ax[0].set_ylim(0.75,1.35)\n",
    "ax[1].set_ylim(0.03,0.17)\n",
    "ax[0].text(0.55, 1.27, \"$\\lambda = 2$\", rotation=-35, fontsize=10)\n",
    "ax[0].text(0.55, 1.01, \"$\\lambda = 1$\", fontsize=10)\n",
    "ax[0].text(0.55, 0.87, \"$\\lambda = 0.5$\", rotation=35, fontsize=10)\n",
    "\n",
    "ax[1].text(0.5, 0.05, \"$\\lambda = 2$\", rotation=15, fontsize=10)\n",
    "ax[1].text(0.5, 0.11, \"$\\lambda = 1$\", fontsize=10)\n",
    "ax[1].text(0.5, 0.155, \"$\\lambda = 0.5$\", rotation=-10, fontsize=10)\n",
    "\n",
    "\n",
    "#plt.savefig('./figures/full_div_strategy.eps',bbox_inches='tight')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4115deeb",
   "metadata": {},
   "outputs": [],
   "source": [
    "tmax=6\n",
    "ncells=20\n",
    "start = time.time()\n",
    "sim = Simulator(ncells=ncells, gr=np.log(2), sb=mean_size, steps=div_steps)\n",
    "sim.szdyn(tmax=tmax,sample_time=0.05,nameCRM=\"./data/SingleLin.csv\")\n",
    "print('It took', np.int(time.time()-start), 'seconds.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f9142ff7",
   "metadata": {},
   "outputs": [],
   "source": [
    "#ploting Figure2\n",
    "fig= plt.figure(figsize=(15,2))\n",
    "gs0 = gridspec.GridSpec(1, 3, figure=fig,wspace=0.2)\n",
    "\n",
    "ax0 = fig.add_subplot(gs0[1])\n",
    "\n",
    "data=pd.read_csv(\"./data/AdderDyn.csv\")\n",
    "ax0.plot(data.time,data.Meansize,c='#00609B')\n",
    "ax0.set_ylim(0)\n",
    "\n",
    "data=pd.read_csv(\"./data/dataFSPsz.csv\")\n",
    "ax0.plot(data.time,data.Meansize,c='r')\n",
    "\n",
    "data=pd.read_csv(\"./data/dataFSPtim.csv\")\n",
    "ax0.plot(data.time,data.Meansize,c='g')\n",
    "\n",
    "\n",
    "setaxis(ax0)\n",
    "\n",
    "ax1 = fig.add_subplot(gs0[2])\n",
    "ax1.set_ylim(0,0.3)\n",
    "ax0.set_ylim(1,1.7)\n",
    "ax0.set_xlim(0,6)\n",
    "ax1.set_xlim(0,6)\n",
    "\n",
    "ax0.set_title('Dynamics of the mean cell size')\n",
    "ax1.set_title('Dynamics of the cell size fluctuations')\n",
    "\n",
    "data=pd.read_csv(\"./data/AdderDyn.csv\")\n",
    "ax1.plot(data.time,data.VarSize,c='#00609B')\n",
    "\n",
    "data=pd.read_csv(\"./data/dataFSPtim.csv\")\n",
    "ax1.plot(data.time,data.VarSize,c='g')       \n",
    "\n",
    "data=pd.read_csv(\"./data/dataFSPsz.csv\")\n",
    "ax1.plot(data.time,data.VarSize,c='r') \n",
    "setaxis(ax1)\n",
    "gs00 = gridspec.GridSpecFromSubplotSpec(1,2, subplot_spec=gs0[0],wspace=0.3)\n",
    "ax20 = fig.add_subplot(gs00[0])\n",
    "ax21 = fig.add_subplot(gs00[1])\n",
    "\n",
    "ax20.set_xlim(0.45,1.55)\n",
    "ax21.set_xlim(0.5,1.5)\n",
    "ax20.set_ylim(0.7,1.35)\n",
    "ax21.set_ylim(0,0.2)\n",
    "\n",
    "ax20.plot(np.array(sbar)/mean_size, np.array(delttim)/mean_size, lw=2,c='g', label=\"$\\lambda=0.5$\")\n",
    "ax21.plot(np.array(sbar)/mean_size, cv2tim, lw=2, c='g')\n",
    "\n",
    "ax20.plot(np.array(sbar)/mean_size, np.array(deltad)/mean_size, lw=2, c='#00609B', label=\"$\\lambda=1$\")\n",
    "ax21.plot(np.array(sbar)/mean_size, cv2ad, lw=2, c='#00609B')\n",
    "\n",
    "ax20.plot(np.array(sbar)/mean_size, np.array(deltsz)/mean_size, lw=2, c='r', label=\"$\\lambda=2$\")\n",
    "ax21.plot(np.array(sbar)/mean_size, cv2sz, lw=2, c='r')\n",
    "\n",
    "ax20.errorbar(np.array(sbarr1), np.array(deltarr1), xerr=errsbarr1, yerr=errdeltarr1, fmt='o', mec='k',\n",
    "              capsize=3,markersize='5', elinewidth=3, c='#00609B')\n",
    "ax21.errorbar(np.array(sbarr1), CV2darr1, xerr=errsbarr1, yerr=errcv2darr1, fmt='o', mec='k', capsize=3,\n",
    "               markersize='5', elinewidth=3, c='#00609B')\n",
    "\n",
    "ax20.errorbar(np.array(sbarr2), np.array(deltarr2), xerr=errsbarr2, yerr=errdeltarr2, fmt='o', mec='k',\n",
    "              capsize=5, markersize='5', elinewidth=3, c='r')\n",
    "ax21.errorbar(np.array(sbarr2), CV2darr2, xerr=errsbarr2, yerr=errcv2darr2, fmt='o', mec='k', capsize=5,\n",
    "               markersize='5', elinewidth=3, c='r')\n",
    "\n",
    "ax20.errorbar(np.array(sbarr3), np.array(deltarr3), xerr=errsbarr3, yerr=errdeltarr3, fmt='o', mec='k',\n",
    "              capsize=5, markersize='5', elinewidth=3, c='g')\n",
    "ax21.errorbar(np.array(sbarr3), CV2darr3, xerr=errsbarr3, yerr=errcv2darr3, fmt='o', mec='k', \n",
    "              capsize=5, markersize='5', elinewidth=3, c='g')\n",
    "setaxis(ax20)\n",
    "setaxis(ax21)\n",
    "\n",
    "ax20.set_xlabel('Size at Birth')\n",
    "ax21.set_xlabel('Size at Birth')\n",
    "ax20.set_ylabel('Added Size')\n",
    "ax21.set_ylabel('Noise in Added Size')\n",
    "\n",
    "ax20.set_ylabel('Division strategy')\n",
    "\n",
    "ax0.set_xlabel('Time')\n",
    "ax1.set_xlabel('Time')\n",
    "ax0.set_ylabel('Cell Size')\n",
    "ax1.set_ylabel('Noise in Cell Size')\n",
    "\n",
    "ax20.text(0.65,1.21,r'Sizer-like')\n",
    "ax20.text(0.45,1.02,r'Adder')\n",
    "ax20.text(0.72,0.81,r'Timer-like')\n",
    "plt.savefig('./figures/full_div_strategy.eps',bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a83628b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Simulation of size trajectories for coupling to gene expression\n",
    "from PyEcoLib.PopSimulator import PopSimulator\n",
    "sim = PopSimulator(ncells=5000,gr=np.log(2), sb=1, steps=10, nu=1,V0array=np.random.gamma(shape=1/0.03,scale=0.03,size=5000)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dcbe4256",
   "metadata": {},
   "outputs": [],
   "source": [
    "sim.szdyn(tmax=5,sample_time=0.1,DivEventsFile='./data/DivEvents.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6dae1a66",
   "metadata": {},
   "outputs": [],
   "source": [
    "#implementation of gene expression algorithm\n",
    "df=pd.read_csv('./data/DivEvents.csv')\n",
    "dt=0.01\n",
    "tmax=5\n",
    "\n",
    "b=10\n",
    "kr=10*np.log(2)\n",
    "dataf=[]\n",
    "for cell in df.Cell.unique():\n",
    "    p=100\n",
    "    dfcell=df[df.Cell==cell]\n",
    "    reactimes=dfcell.BirthTime.tolist()\n",
    "    grarr=dfcell.GrowthRate.tolist()\n",
    "    sbarr=dfcell.Sb.tolist()\n",
    "    sdarr=dfcell.MotherSize.tolist()\n",
    "    td=reactimes[1]\n",
    "    gr=grarr[0]\n",
    "    s=sbarr[0]\n",
    "    \n",
    "    tr=(1/gr)*np.log(1-(gr/(s*kr))*np.log(np.random.rand()))\n",
    "    \n",
    "    nextt=np.min([tr,td])\n",
    "    react=np.argmin([tr,td])\n",
    "    t=0\n",
    "    ndivs=0\n",
    "    dataf.append([cell,t,p,s,p/s]) #data sampling\n",
    "    while t<=tmax:\n",
    "        tt=dt\n",
    "        if nextt<tt:\n",
    "            while nextt<tt:\n",
    "                s*=np.exp(gr*nextt)\n",
    "                td+=-nextt\n",
    "                tr+=-nextt\n",
    "                tt+=-nextt\n",
    "                if react==0: #express gene\n",
    "                    p+=np.random.geometric(p=1/10)\n",
    "                    tr=(1/gr)*np.log(1-(gr/(s*kr))*np.log(np.random.rand()))\n",
    "                else:\n",
    "                    ndivs+=1\n",
    "                    if ndivs<len(reactimes)-1:   \n",
    "                        td=reactimes[ndivs+1]-reactimes[ndivs]\n",
    "                    else:\n",
    "                        td=tmax+2*dt\n",
    "                    f=sbarr[ndivs]/sdarr[ndivs]\n",
    "                    gr=grarr[ndivs]\n",
    "                    s=sbarr[ndivs]\n",
    "                    p=np.random.binomial(p,f)                    \n",
    "                nextt=np.min([tr,td])\n",
    "                react=np.argmin([tr,td])\n",
    "            s*=np.exp(gr*tt)\n",
    "            td+=-tt\n",
    "            tr+=-tt\n",
    "        else:\n",
    "            nextt+=-dt #the sampling time is shorter than the closest reaction time\n",
    "            s*=np.exp(gr*dt)\n",
    "            td+=-dt\n",
    "            tr+=-dt\n",
    "        t+=dt\n",
    "        dataf.append([cell,t,p,s,p/s]) #data sampling\n",
    "\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "430448ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Exporting gene expression data\n",
    "datagen=pd.DataFrame(dataf,columns=['Cell','Time','Np','Sz','p'])\n",
    "datagen.to_csv('./data/GeneExpression.csv',index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da8c10b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "#ploting Figure4\n",
    "datagen=pd.read_csv('./data/GeneExpression.csv')\n",
    "fig, ax = plt.subplots(2, 3, figsize=(12, 4),sharex=True)\n",
    "\n",
    "for cell in datagen.Cell.unique()[:10]:\n",
    "    datacell=datagen[datagen.Cell==cell]\n",
    "    ax[0,0].plot(datacell.Time,datacell.Sz,c='#008EE4',lw=0.7)\n",
    "\n",
    "mnarr=[]\n",
    "cv2arr=[]\n",
    "for t in datagen.Time.unique():\n",
    "    datatime=datagen[datagen.Time==t]\n",
    "    mnarr.append(np.mean(datatime.Sz))\n",
    "    cv2arr.append(np.var(datatime.Sz)/np.mean(datatime.Sz)**2)\n",
    "ax[0,0].plot(datagen.Time.unique(),mnarr,c=\"#005A91\")\n",
    "ax[1,0].plot(datagen.Time.unique(),cv2arr,c=\"#005A91\")\n",
    "\n",
    "for cell in datagen.Cell.unique()[:10]:\n",
    "    datacell=datagen[datagen.Cell==cell]\n",
    "    ax[0,1].plot(datacell.Time,datacell.Np,c='#FE4B2B',lw=0.7)\n",
    "\n",
    "mnarr=[]\n",
    "cv2arr=[]\n",
    "for t in datagen.Time.unique():\n",
    "    datatime=datagen[datagen.Time==t]\n",
    "    mnarr.append(np.mean(datatime.Np))\n",
    "    cv2arr.append(np.var(datatime.Np)/np.mean(datatime.Np)**2)\n",
    "ax[0,1].plot(datagen.Time.unique(),mnarr,c=\"#D32000\")\n",
    "ax[1,1].plot(datagen.Time.unique(),cv2arr,c=\"#D32000\")\n",
    "\n",
    "\n",
    "for cell in datagen.Cell.unique()[:10]:\n",
    "    datacell=datagen[datagen.Cell==cell]\n",
    "    ax[0,2].plot(datacell.Time,datacell.p,c='#AF49FF',lw=0.7)\n",
    "\n",
    "mnarr=[]\n",
    "cv2arr=[]\n",
    "for t in datagen.Time.unique():\n",
    "    datatime=datagen[datagen.Time==t]\n",
    "    mnarr.append(np.mean(datatime.p))\n",
    "    cv2arr.append(np.var(datatime.p)/np.mean(datatime.p)**2)\n",
    "ax[0,2].plot(datagen.Time.unique(),mnarr,c=\"#7200CC\")\n",
    "ax[1,2].plot(datagen.Time.unique(),cv2arr,c=\"#7200CC\")\n",
    "for i in [0,1]:\n",
    "    for j in [0,1,2]:\n",
    "        setaxis(ax[i,j])\n",
    "        ax[i,j].set_xlim(0,5)\n",
    "ax[0,0].set_ylabel(r'Cell Size, $s$')\n",
    "ax[0,1].set_ylabel(r'Protein Number, $n$')\n",
    "ax[0,2].set_ylabel(r'Protein Concentration, $p$')\n",
    "\n",
    "ax[1,0].set_ylabel(r'Size Fluctuations $CV^2_s$')\n",
    "ax[1,1].set_ylabel(r'Number Fluctuations $CV^2_n$')\n",
    "ax[1,2].set_ylabel(r'Conc. Fluctuations $CV^2_p$')\n",
    "\n",
    "ax[1,0].set_xlabel(r'Time')\n",
    "ax[1,1].set_xlabel(r'Time')\n",
    "ax[1,2].set_xlabel(r'Time')\n",
    "\n",
    "ax[1,0].set_ylim(0,0.15)\n",
    "ax[1,1].set_ylim(0,0.2)\n",
    "ax[1,2].set_ylim(0,0.08)\n",
    "\n",
    "ax[0,0].set_title('Size Dynamics')\n",
    "ax[0,1].set_title('Protein Number Dynamics')\n",
    "ax[0,2].set_title('Protein Concentration Dynamics')\n",
    "\n",
    "plt.savefig('./figures/gene.eps',bbox_inches='tight',dpi=600)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2458e30f",
   "metadata": {},
   "source": [
    "Estimating effects of cells division noise in gene expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c7c52454",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Simulating Cell trajectories and times to division\n",
    "from PyEcoLib.PopSimulator import PopSimulator\n",
    "for nstps in [1,2,3,5,10,20,30]:\n",
    "    sim = PopSimulator(ncells=5000,gr=np.log(2), sb=1, \n",
    "                       steps=nstps, nu=1,V0array=np.random.gamma(shape=1/0.1,scale=0.1,size=5000))\n",
    "    sim.szdyn(tmax=5,sample_time=0.1,DivEventsFile=f'./data/DivEvents{nstps}.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8bf4ec6c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Changing number of division steps\n",
    "dataf=[]\n",
    "for nstps in [1,2,3,5,10,20,30]:\n",
    "\n",
    "    df=pd.read_csv(f'./data/DivEvents{nstps}.csv')\n",
    "    dt=0.01\n",
    "    tmax=5\n",
    "\n",
    "    kr=4*np.log(2)\n",
    "    \n",
    "    for cell in tqdm(df.Cell.unique()):\n",
    "        p=np.random.poisson(lam=10)\n",
    "        dfcell=df[df.Cell==cell]\n",
    "        reactimes=dfcell.BirthTime.tolist()\n",
    "        grarr=dfcell.GrowthRate.tolist()\n",
    "        sbarr=dfcell.Sb.tolist()\n",
    "        sdarr=dfcell.MotherSize.tolist()\n",
    "        if len(reactimes)>1:\n",
    "            td=reactimes[1]\n",
    "            gr=grarr[0]\n",
    "            s=sbarr[0]\n",
    "\n",
    "            tr=(1/gr)*np.log(1-(gr/(s*kr))*np.log(np.random.rand()))\n",
    "\n",
    "            nextt=np.min([tr,td])\n",
    "            react=np.argmin([tr,td])\n",
    "            t=0\n",
    "            ndivs=0\n",
    "            dataf.append([nstps,cell,t,p,s,p/s]) #data sampling\n",
    "            while t<=tmax:\n",
    "                tt=dt\n",
    "                if nextt<tt:\n",
    "                    while nextt<tt:\n",
    "                        s*=np.exp(gr*nextt)\n",
    "                        td+=-nextt\n",
    "                        tr+=-nextt\n",
    "                        tt+=-nextt\n",
    "                        if react==0: #express gene\n",
    "                            p+=np.random.geometric(p=1/5)\n",
    "                            tr=(1/gr)*np.log(1-(gr/(s*kr))*np.log(np.random.rand()))\n",
    "                        else:\n",
    "                            ndivs+=1\n",
    "                            if ndivs<len(reactimes)-1:   \n",
    "                                td=reactimes[ndivs+1]-reactimes[ndivs]\n",
    "                            else:\n",
    "                                td=tmax+2*dt\n",
    "                            f=sbarr[ndivs]/sdarr[ndivs]\n",
    "                            gr=grarr[ndivs]\n",
    "                            s=sbarr[ndivs]\n",
    "                            p=np.random.binomial(p,f)                    \n",
    "                        nextt=np.min([tr,td])\n",
    "                        react=np.argmin([tr,td])\n",
    "                    s*=np.exp(gr*tt)\n",
    "                    td+=-tt\n",
    "                    tr+=-tt\n",
    "                else:\n",
    "                    nextt+=-dt #the sampling time is shorter than the closest reaction time\n",
    "                    s*=np.exp(gr*dt)\n",
    "                    td+=-dt\n",
    "                    tr+=-dt\n",
    "                t+=dt\n",
    "                dataf.append([nstps,cell,t,p,s,p/s]) #data sampling\n",
    "\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f782e16f",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Saving different division steps\n",
    "datagen=pd.DataFrame(dataf,columns=['Stp','Cell','Time','Np','Sz','p'])\n",
    "datagen.to_csv('./data/GeneExpressionstp.csv',index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b037bdb4",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Estimating the statistics for differnet division steps\n",
    "data=pd.read_csv('./data/GeneExpressionstp.csv')\n",
    "for stp in data.Stp.unique():\n",
    "    datastp=data[data.Stp==stp]\n",
    "    tmax=datastp.Time.tolist()[-1]\n",
    "    datat=datastp[datastp.Time==tmax]\n",
    "    print(np.mean(datat.p),np.var(datat.p)/np.mean(datat.p))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84f90db9",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Simulating cell size trajectories for different noise levels in growth rate\n",
    "from PyEcoLib.PopSimulator import PopSimulator\n",
    "ncells=5000\n",
    "for cv2gr in tqdm([0.001,0.01,0.02,0.04,0.06,0.08,0.1]):\n",
    "    sim = PopSimulator(ncells=ncells,gr=np.log(2), sb=1, \n",
    "                       steps=10, nu=1,V0array=np.random.gamma(shape=1/0.5,scale=0.5,size=ncells),CV2gr=cv2gr)\n",
    "    sim.szdyn(tmax=5,sample_time=0.1,DivEventsFile=f'./data/DivEventscv2gr{int(10000*cv2gr)}.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "67a672c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Simulating Gene expression for different noise levels in growth rate\n",
    "dataf=[]\n",
    "for cv2gr in [0.001,0.01,0.02,0.04,0.06,0.08,0.1]:\n",
    "\n",
    "    df=pd.read_csv(f'./data/DivEventscv2gr{int(10000*cv2gr)}.csv')\n",
    "    dt=0.01\n",
    "    tmax=5\n",
    "\n",
    "    b=1\n",
    "    kr=4*np.log(2)\n",
    "    \n",
    "    for cell in tqdm(df.Cell.unique()):\n",
    "        p=np.random.poisson(lam=10)\n",
    "        dfcell=df[df.Cell==cell]\n",
    "        reactimes=dfcell.BirthTime.tolist()\n",
    "        grarr=dfcell.GrowthRate.tolist()\n",
    "        sbarr=dfcell.Sb.tolist()\n",
    "        sdarr=dfcell.MotherSize.tolist()\n",
    "        if len(reactimes)>1:\n",
    "            td=reactimes[1]\n",
    "            gr=grarr[0]\n",
    "            s=sbarr[0]\n",
    "\n",
    "            tr=(1/gr)*np.log(1-(gr/(s*kr))*np.log(np.random.rand()))\n",
    "\n",
    "            nextt=np.min([tr,td])\n",
    "            react=np.argmin([tr,td])\n",
    "            t=0\n",
    "            ndivs=0\n",
    "            dataf.append([cv2gr,cell,t,p,s,p/s]) #data sampling\n",
    "            while t<=tmax:\n",
    "                tt=dt\n",
    "                if nextt<tt:\n",
    "                    while nextt<tt:\n",
    "                        s*=np.exp(gr*nextt)\n",
    "                        td+=-nextt\n",
    "                        tr+=-nextt\n",
    "                        tt+=-nextt\n",
    "                        if react==0: #express gene\n",
    "                            p+=np.random.geometric(p=1/5)\n",
    "                            tr=(1/gr)*np.log(1-(gr/(s*kr))*np.log(np.random.rand()))\n",
    "                        else:\n",
    "                            ndivs+=1\n",
    "                            if ndivs<len(reactimes)-1:   \n",
    "                                td=reactimes[ndivs+1]-reactimes[ndivs]\n",
    "                            else:\n",
    "                                td=tmax+2*dt\n",
    "                            f=sbarr[ndivs]/sdarr[ndivs]\n",
    "                            gr=grarr[ndivs]\n",
    "                            s=sbarr[ndivs]\n",
    "                            p=np.random.binomial(p,f)                    \n",
    "                        nextt=np.min([tr,td])\n",
    "                        react=np.argmin([tr,td])\n",
    "                    s*=np.exp(gr*tt)\n",
    "                    td+=-tt\n",
    "                    tr+=-tt\n",
    "                else:\n",
    "                    nextt+=-dt #the sampling time is shorter than the closest reaction time\n",
    "                    s*=np.exp(gr*dt)\n",
    "                    td+=-dt\n",
    "                    tr+=-dt\n",
    "                t+=dt\n",
    "                dataf.append([cv2gr,cell,t,p,s,p/s]) #data sampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9fda6346",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Saving data\n",
    "datagen=pd.DataFrame(dataf,columns=['CV2gr','Cell','Time','Np','Sz','p'])\n",
    "datagen.to_csv('./data/GeneExpressioncv2gr.csv',index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c310997",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Simulating cell size trajectories for different noise levels in partitioning position\n",
    "from PyEcoLib.PopSimulator import PopSimulator\n",
    "ncells=5000\n",
    "for cv2div in tqdm([0.001,0.01,0.02,0.04,0.06,0.08,0.1]):\n",
    "    sim = PopSimulator(ncells=ncells,gr=np.log(2), sb=1, \n",
    "                       steps=10, nu=1,V0array=np.random.gamma(shape=1/0.5,scale=0.5,size=ncells),\n",
    "                       CV2div=cv2div)\n",
    "    sim.szdyn(tmax=5,sample_time=0.1,DivEventsFile=f'./data/DivEventscv2div{int(10000*cv2div)}.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e15988c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Simulating gene expression for different noise levels in partitioning position\n",
    "dataf=[]\n",
    "\n",
    "for cv2div in [0.001,0.01,0.02,0.04,0.06,0.08,0.1]:\n",
    "    df=pd.read_csv(f'./data/DivEventscv2div{int(10000*cv2div)}.csv')\n",
    "    dt=0.01\n",
    "    tmax=5\n",
    "\n",
    "    b=1\n",
    "    kr=4*np.log(2)\n",
    "    \n",
    "    for cell in tqdm(df.Cell.unique()):\n",
    "        p=np.random.poisson(lam=10)\n",
    "        dfcell=df[df.Cell==cell]\n",
    "        reactimes=dfcell.BirthTime.tolist()\n",
    "        grarr=dfcell.GrowthRate.tolist()\n",
    "        sbarr=dfcell.Sb.tolist()\n",
    "        sdarr=dfcell.MotherSize.tolist()\n",
    "        if len(reactimes)>1:\n",
    "            td=reactimes[1]\n",
    "            gr=grarr[0]\n",
    "            s=sbarr[0]\n",
    "\n",
    "            tr=(1/gr)*np.log(1-(gr/(s*kr))*np.log(np.random.rand()))\n",
    "\n",
    "            nextt=np.min([tr,td])\n",
    "            react=np.argmin([tr,td])\n",
    "            t=0\n",
    "            ndivs=0\n",
    "            dataf.append([cv2div,cell,t,p,s,p/s]) #data sampling\n",
    "            while t<=tmax:\n",
    "                tt=dt\n",
    "                if nextt<tt:\n",
    "                    while nextt<tt:\n",
    "                        s*=np.exp(gr*nextt)\n",
    "                        td+=-nextt\n",
    "                        tr+=-nextt\n",
    "                        tt+=-nextt\n",
    "                        if react==0: #express gene\n",
    "                            p+=np.random.geometric(p=1/5)\n",
    "                            tr=(1/gr)*np.log(1-(gr/(s*kr))*np.log(np.random.rand()))\n",
    "                        else:\n",
    "                            ndivs+=1\n",
    "                            if ndivs<len(reactimes)-1:   \n",
    "                                td=reactimes[ndivs+1]-reactimes[ndivs]\n",
    "                            else:\n",
    "                                td=tmax+2*dt\n",
    "                            f=sbarr[ndivs]/sdarr[ndivs]\n",
    "                            gr=grarr[ndivs]\n",
    "                            s=sbarr[ndivs]\n",
    "                            p=np.random.binomial(p,f)                    \n",
    "                        nextt=np.min([tr,td])\n",
    "                        react=np.argmin([tr,td])\n",
    "                    s*=np.exp(gr*tt)\n",
    "                    td+=-tt\n",
    "                    tr+=-tt\n",
    "                else:\n",
    "                    nextt+=-dt #the sampling time is shorter than the closest reaction time\n",
    "                    s*=np.exp(gr*dt)\n",
    "                    td+=-dt\n",
    "                    tr+=-dt\n",
    "                t+=dt\n",
    "                dataf.append([cv2div,cell,t,p,s,p/s]) #data sampling\n",
    "\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d5622f2c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Saving data\n",
    "datagen=pd.DataFrame(dataf,columns=['CV2div','Cell','Time','Np','Sz','p'])\n",
    "datagen.to_csv('./data/GeneExpressioncv2div.csv',index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51064731",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Estimating statistics \n",
    "datagen=pd.read_csv('./data/GeneExpressioncv2gr.csv')\n",
    "for stp in datagen.CV2gr.unique():\n",
    "    datastp=datagen[datagen.CV2gr==stp]\n",
    "    tmax=datastp.Time.tolist()[-1]\n",
    "    datat=datastp[datastp.Time==tmax]\n",
    "    print(np.mean(datat.p),np.var(datat.p)/np.mean(datat.p)**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b29fd981",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Estimating statistics\n",
    "datagen=pd.read_csv('./data/GeneExpressioncv2div.csv')\n",
    "for stp in datagen.CV2div.unique():\n",
    "    datastp=datagen[datagen.CV2div==stp]\n",
    "    tmax=datastp.Time.tolist()[-1]\n",
    "    datat=datastp[datastp.Time==tmax]\n",
    "    print(np.mean(datat.p),np.var(datat.p)/np.mean(datat.p)**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "769e6866",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "def bootstrap(arr):\n",
    "    mnar=np.empty(100)\n",
    "    cv2ar=np.empty(100)\n",
    "    for l in range(100):\n",
    "        boot=random.choices(arr,k=len(arr))\n",
    "        mn=np.mean(boot)\n",
    "        cv2=np.var(boot)/np.mean(boot)**2\n",
    "        mnar[l]=mn\n",
    "        cv2ar[l]=cv2\n",
    "    mn=np.mean(mnar)\n",
    "    up=np.quantile(mnar,0.95)\n",
    "    down=np.quantile(mnar,0.05)\n",
    "    cv2=np.mean(cv2ar)\n",
    "    up2=np.quantile(cv2ar,0.95)\n",
    "    down2=np.quantile(cv2ar,0.05)\n",
    "    return(mn,0.5*(-down+up),cv2,0.5*(-down2+up2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf0b2ec7",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Ploting Figure5\n",
    "props2 = dict(boxstyle='round',facecolor= '#FFFFFF',linewidth=1,edgecolor='#AEAEAE')\n",
    "\n",
    "fig= plt.figure(figsize=(13,5))\n",
    "gs0 = gridspec.GridSpec(2, 3, figure=fig,wspace=0.25,hspace=0.4)\n",
    "\n",
    "gs00 = gridspec.GridSpecFromSubplotSpec(2,2, subplot_spec=gs0[0,0],wspace=0.1)\n",
    "ax20 = fig.add_subplot(gs00[0,0])\n",
    "ax21 = fig.add_subplot(gs00[1,0])\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "data=pd.read_csv('./data/GeneExpressionstp.csv')\n",
    "df=data[data.Stp==10]\n",
    "cmap = matplotlib.cm.get_cmap('YlGn')\n",
    "color=np.linspace(0.2,0.8,10)\n",
    "\n",
    "i=0\n",
    "for cell in df.Cell.unique()[0:10]:\n",
    "    dfcell=df[df.Cell==cell]\n",
    "    clr=cmap(color[i])\n",
    "    ax20.plot(dfcell.Time,dfcell.Sz,c=clr,lw=1)\n",
    "    ax21.plot(dfcell.Time,dfcell.p,c=clr,lw=1)\n",
    "    i+=1\n",
    "\n",
    "\n",
    "ax20.set_ylabel('Cell Size')\n",
    "ax20.text(0.3,4.5,r'steps=10',bbox=props2,fontsize=9)\n",
    "ax21.text(0.3,65,r'steps=10',bbox=props2,fontsize=9)\n",
    "ax20.set_ylim(0,6)\n",
    "ax21.set_ylim(0,90)\n",
    "ax21.set_ylabel('Prot. Conc.')\n",
    "ax20.set_xlim(0,5)\n",
    "ax21.set_xlim(0,5) \n",
    "setaxis(ax21)\n",
    "setaxis(ax20)\n",
    "ax21.set_xlabel('time')\n",
    "    \n",
    "ax20 = fig.add_subplot(gs00[0,1])\n",
    "ax21 = fig.add_subplot(gs00[1,1])\n",
    "\n",
    "data=pd.read_csv('./data/GeneExpressionstp.csv')\n",
    "df=data[data.Stp==1]\n",
    "i=0\n",
    "for cell in df.Cell.unique()[20:30]:\n",
    "    dfcell=df[df.Cell==cell]\n",
    "    clr=cmap(color[i])\n",
    "    ax20.plot(dfcell.Time,dfcell.Sz,c=clr,lw=1)\n",
    "    ax21.plot(dfcell.Time,dfcell.p,c=clr,lw=1)\n",
    "    i+=1\n",
    "\n",
    "ax20.text(0.3,4.5,r'steps=1',bbox=props2,fontsize=9)\n",
    "ax21.text(0.3,65,r'steps=1',bbox=props2,fontsize=9)\n",
    "ax20.set_ylim(0,6)\n",
    "ax21.set_ylim(0,90)\n",
    "ax20.set_xlim(0,5)\n",
    "ax21.set_xlim(0,5) \n",
    "setaxis(ax21)\n",
    "setaxis(ax20)\n",
    "ax21.set_xlabel('time')\n",
    "\n",
    "ax10=fig.add_subplot(gs0[1,0])\n",
    "\n",
    "\n",
    "noisesar=[]\n",
    "noiseser=[]\n",
    "noisesz=[]\n",
    "noisesz=[]\n",
    "for stp in data.Stp.unique():\n",
    "    datastp=data[data.Stp==stp]\n",
    "    tmax=datastp.Time.tolist()[-1]\n",
    "    datat=datastp[datastp.Time==tmax]\n",
    "    parr=datat.p.tolist()\n",
    "    mn,err,cv2,cv2err=bootstrap(parr)\n",
    "    noisesar.append(cv2)\n",
    "    noiseser.append(cv2err)\n",
    "    noisesz.append(1/stp)\n",
    "\n",
    "ax10.errorbar(noisesz,noisesar,yerr=noiseser,capsize=3,fmt='o',ls='--',color=clr,markersize=5)\n",
    "setaxis(ax10)\n",
    "ax10.set_ylim(0.15,0.25)\n",
    "ax10.set_yticks([0.15,0.20,0.25])\n",
    "ax10.set_ylabel(r'Protein Noise, $CV^2_p$')\n",
    "ax10.set_xlabel(r'Noise in Added Size, $CV^2_\\Delta$')\n",
    "ax10.text(0.05,0.23,r'$CV^2_{gr}=0,CV^2_{div}=0$',bbox=props2)\n",
    "#ax10.set_ylim(0)\n",
    "#==============================================================================\n",
    "\n",
    "gs00 = gridspec.GridSpecFromSubplotSpec(2,2, subplot_spec=gs0[0,1],wspace=0.1)\n",
    "ax20 = fig.add_subplot(gs00[0,0])\n",
    "ax21 = fig.add_subplot(gs00[1,0])\n",
    "\n",
    "data=pd.read_csv('./data/GeneExpressioncv2gr.csv')\n",
    "df=data[data.CV2gr==0.001]\n",
    "i=0\n",
    "cmap = matplotlib.cm.get_cmap('BuPu')\n",
    "for cell in df.Cell.unique()[0:10]:\n",
    "    dfcell=df[df.Cell==cell]\n",
    "    clr=cmap(color[i])\n",
    "    ax20.plot(dfcell.Time,dfcell.Sz,c=clr,lw=1)\n",
    "    ax21.plot(dfcell.Time,dfcell.p,c=clr,lw=1)\n",
    "    i+=1\n",
    "ax20.text(0.3,4.5,r'$CV^2_{gr}=10^{-3}$',bbox=props2,fontsize=9)\n",
    "ax21.text(0.3,65,r'$CV^2_{gr}=10^{-3}$',bbox=props2,fontsize=9)\n",
    "ax20.set_ylim(0,6)\n",
    "ax21.set_ylim(0,90)\n",
    "ax20.set_ylabel('Cell Size')\n",
    "\n",
    "ax21.set_ylabel('Prot. Conc.')\n",
    "ax20.set_xlim(0,5)\n",
    "ax21.set_xlim(0,5) \n",
    "setaxis(ax21)\n",
    "setaxis(ax20)\n",
    "ax21.set_xlabel('time')\n",
    "\n",
    "ax20 = fig.add_subplot(gs00[0,1])\n",
    "ax21 = fig.add_subplot(gs00[1,1])\n",
    "\n",
    "df=data[data.CV2gr==0.1]\n",
    "i=0\n",
    "for cell in df.Cell.unique()[0:10]:\n",
    "    dfcell=df[df.Cell==cell]\n",
    "    clr=cmap(color[i])\n",
    "    ax20.plot(dfcell.Time,dfcell.Sz,c=clr,lw=1)\n",
    "    ax21.plot(dfcell.Time,dfcell.p,c=clr,lw=1)\n",
    "    i+=1\n",
    "ax20.text(0.3,4.5,r'$CV^2_{gr}=10^{-1}$',bbox=props2,fontsize=9)\n",
    "ax21.text(0.3,65,r'$CV^2_{gr}=10^{-1}$',bbox=props2,fontsize=9)\n",
    "ax20.set_ylim(0,6)\n",
    "ax21.set_ylim(0,90)\n",
    "ax20.set_xlim(0,5)\n",
    "ax21.set_xlim(0,5) \n",
    "setaxis(ax21)\n",
    "setaxis(ax20)\n",
    "ax21.set_xlabel('time')\n",
    "\n",
    "ax10=fig.add_subplot(gs0[1,1])\n",
    "\n",
    "noisesar=[]\n",
    "noiseser=[]\n",
    "noisesz=[]\n",
    "noisesz=[]\n",
    "for stp in data.CV2gr.unique():\n",
    "    datastp=data[data.CV2gr==stp]\n",
    "    tmax=datastp.Time.tolist()[-1]\n",
    "    datat=datastp[datastp.Time==tmax]\n",
    "    parr=datat.p.tolist()\n",
    "    mn,err,cv2,cv2err=bootstrap(parr)\n",
    "    noisesar.append(cv2)\n",
    "    noiseser.append(cv2err)\n",
    "    noisesz.append(stp)\n",
    "\n",
    "ax10.errorbar(noisesz,noisesar,yerr=noiseser,capsize=3,fmt='o',ls='--',color=clr,markersize=5)\n",
    "setaxis(ax10)\n",
    "ax10.set_ylim(0.15,0.25)\n",
    "ax10.set_yticks([0.15,0.20,0.25])\n",
    "ax10.set_ylabel(r'Protein Noise, $CV^2_p$')\n",
    "ax10.set_xlabel(r'Noise in Growth rate, $CV^2_{gr}$')\n",
    "ax10.text(0.001,0.23,r'steps$=10,CV^2_{div}=0$',bbox=props2)\n",
    "#ax10.set_ylim(0)\n",
    "#================================================================\n",
    "\n",
    "gs00 = gridspec.GridSpecFromSubplotSpec(2,2, subplot_spec=gs0[0,2],wspace=0.1)\n",
    "ax20 = fig.add_subplot(gs00[0,0])\n",
    "ax21 = fig.add_subplot(gs00[1,0])\n",
    "\n",
    "data=pd.read_csv('./data/GeneExpressioncv2div.csv')\n",
    "df=data[data.CV2div==0.001]\n",
    "\n",
    "cmap = matplotlib.cm.get_cmap('GnBu')\n",
    "i=0\n",
    "\n",
    "for cell in df.Cell.unique()[10:20]:\n",
    "    dfcell=df[df.Cell==cell]\n",
    "    clr=cmap(color[i])\n",
    "    ax20.plot(dfcell.Time,dfcell.Sz,c=clr,lw=1)\n",
    "    ax21.plot(dfcell.Time,dfcell.p,c=clr,lw=1)\n",
    "    i+=1\n",
    "ax20.text(0.3,4.5,r'$CV^2_{div}=10^{-3}$',bbox=props2,fontsize=9)\n",
    "ax21.text(0.3,65,r'$CV^2_{div}=10^{-3}$',bbox=props2,fontsize=9)\n",
    "ax20.set_ylim(0,6)\n",
    "ax21.set_ylim(0,90)\n",
    "ax20.set_ylabel('Cell Size')\n",
    "ax21.set_ylabel('Prot. Conc.')\n",
    "ax20.set_xlim(0,5)\n",
    "ax21.set_xlim(0,5) \n",
    "setaxis(ax21)\n",
    "setaxis(ax20)\n",
    "ax21.set_xlabel('time')\n",
    "\n",
    "ax20 = fig.add_subplot(gs00[0,1])\n",
    "ax21 = fig.add_subplot(gs00[1,1])\n",
    "\n",
    "df=data[data.CV2div==0.1]\n",
    "i=0\n",
    "for cell in df.Cell.unique()[0:10]:\n",
    "    dfcell=df[df.Cell==cell]\n",
    "    clr=cmap(color[i])\n",
    "    ax20.plot(dfcell.Time,dfcell.Sz,c=clr,lw=1)\n",
    "    ax21.plot(dfcell.Time,dfcell.p,c=clr,lw=1)\n",
    "    i+=1\n",
    "ax20.text(0.3,4.5,r'$CV^2_{div}=10^{-1}$',bbox=props2,fontsize=9)\n",
    "ax21.text(0.3,65,r'$CV^2_{div}=10^{-1}$',bbox=props2,fontsize=9)\n",
    "ax20.set_ylim(0,6)\n",
    "ax21.set_ylim(0,90)\n",
    "ax20.set_xlim(0,5)\n",
    "ax21.set_xlim(0,5)\n",
    "setaxis(ax21)\n",
    "setaxis(ax20)  \n",
    "ax21.set_xlabel('time')\n",
    "\n",
    "ax10=fig.add_subplot(gs0[1,2])\n",
    "\n",
    "noisesar=[]\n",
    "noiseser=[]\n",
    "noisesz=[]\n",
    "noisesz=[]\n",
    "for stp in data.CV2div.unique():\n",
    "    datastp=data[data.CV2div==stp]\n",
    "    tmax=datastp.Time.tolist()[-1]\n",
    "    datat=datastp[datastp.Time==tmax]\n",
    "    parr=datat.p.tolist()\n",
    "    mn,err,cv2,cv2err=bootstrap(parr)\n",
    "    noisesar.append(cv2)\n",
    "    noiseser.append(cv2err)\n",
    "    noisesz.append(stp)\n",
    "\n",
    "ax10.errorbar(noisesz,noisesar,yerr=noiseser,capsize=3,fmt='o',ls='--',color=clr,markersize=5)\n",
    "setaxis(ax10)\n",
    "#,\n",
    "#                   markersize='3',elinewidth=1,fmt='o--')\n",
    "ax10.set_ylim(0.15,0.25)\n",
    "ax10.set_yticks([0.15,0.20,0.25])\n",
    "ax10.set_ylabel(r'Protein Noise, $CV^2_p$')\n",
    "ax10.set_xlabel(r'Noise in Septum Position, $CV^2_{div}$')\n",
    "\n",
    "ax10.text(0.001,0.23,r'steps$=10,CV^2_{gr}=0$',bbox=props2)\n",
    "plt.savefig('./figures/noisesources.eps',bbox_inches='tight',dpi=400)\n"
   ]
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}