Fig3-4.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f2e66f32-e38c-4819-b6d0-d8b696b6dd12",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.transforms as mtransforms\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "from joblib import Parallel, delayed\n",
    "import pickle \n",
    "import os \n",
    "\n",
    "def plot_setup():\n",
    "    plt.rcParams['text.usetex'] = False\n",
    "    plt.rcParams['pdf.fonttype'] = 42\n",
    "    plt.rcParams['ps.fonttype'] = 42\n",
    "    plt.rcParams['mathtext.fontset'] = 'cm'\n",
    "    # plt.rcParams['figure.autolayout'] = 'True'\n",
    "\n",
    "    sns.set_style('ticks',{'axes.edgecolor': '[0,0,0]',\n",
    "                           'xtick.direction':'in',\n",
    "                           'ytick.direction':'in',\n",
    "                           'ytick.right':'True',\n",
    "                           'xtick.top':'True',\n",
    "                           'xtick.color':'k',\n",
    "                           'ytick.color':'k'\n",
    "                            })\n",
    "\n",
    "def gammafunc(size,mu,diff_flag):\n",
    "    if diff_flag == 1:\n",
    "        return 6*np.pi*mu*0.005*size\n",
    "    else:\n",
    "        return 6*np.pi*mu*0.005*3\n",
    "    \n",
    "def diffusion(size,sigma,mu,diff_flag):\n",
    "    gamma_m = 6*np.pi*0.3*0.01\n",
    "    gamma = gammafunc(size,mu,diff_flag)\n",
    "    return ((sigma/(gamma_m+gamma))**2)/2\n",
    "\n",
    "def diffusion_fluid_drag(size,sigma,mu):\n",
    "    gamma_m = 6*np.pi*0.3*0.01\n",
    "    gamma = gammafunc(size,mu,diff_flag)\n",
    "    return ((sigma/(gamma_m+gamma))**2)/2\n",
    "\n",
    "def velocity_fluid_drag(size,mu):\n",
    "    a = 0.005*size\n",
    "    gamma_m = 6*np.pi*0.3*0.01\n",
    "    return (6*np.pi*mu*a)/(gamma_m + 6*np.pi*mu*a)\n",
    "\n",
    "def Pe(r,vc):\n",
    "    return [np.sqrt(np.dot(vc,vc))/np.sqrt(np.dot(v-vc,v-vc)) for v in r]\n",
    "\n",
    "def Sp(r,vc):\n",
    "    return [np.dot(v,vc)/np.sqrt(np.dot(vc,vc)) for v in r]\n",
    "\n",
    "def mc(mu,sigma,kon,kon1,M,model,diff_flag):    \n",
    "    tend = 500\n",
    "    koff = 1\n",
    "    vc = np.array([-0.1,0])\n",
    "    M = int(M)\n",
    "\n",
    "    pe = np.empty((tend,M))\n",
    "    sp = np.empty_like(pe)\n",
    "    velos = np.empty((tend,M,2))\n",
    "    size = np.empty_like(pe)\n",
    "    disp = np.empty_like(pe)\n",
    "    state = np.zeros_like(pe)\n",
    "\n",
    "    if model == 1:\n",
    "        for j in range(M):\n",
    "            cov = 2*diffusion(j+1,sigma,mu,diff_flag)*np.eye(2)\n",
    "            size[:,j] = j+1\n",
    "            v = np.random.default_rng().multivariate_normal(vc,cov,tend)\n",
    "            velos[:,j,:] = v\n",
    "            pe[:,j] = Pe(v,vc)\n",
    "            sp[:,j] = Sp(v,vc)\n",
    "            disp[:,j] = np.sqrt(np.sum(v**2))\n",
    "    elif model == 2:\n",
    "        for j in range(M):\n",
    "            cov = 2*diffusion(j+1,sigma,mu,diff_flag)*np.eye(2)\n",
    "            size[:,j] = j+1\n",
    "            num_bound = np.random.default_rng().binomial(tend,kon/(kon+koff))\n",
    "            vb = np.random.default_rng().multivariate_normal(vc,cov,num_bound)\n",
    "            vu = np.random.default_rng().multivariate_normal(np.array([0,0]),cov,tend-num_bound)\n",
    "            v = np.concatenate((vb,vu))\n",
    "            velos[:,j,:] = v\n",
    "            state[0:num_bound,j] = 1\n",
    "            pe[:,j] = Pe(v,vc)\n",
    "            sp[:,j] = Sp(v,vc)\n",
    "            disp[:,j] = np.sqrt(np.sum(v**2))\n",
    "    elif model == 3:\n",
    "        kon = 5\n",
    "        for j in range(M):\n",
    "            cov = 2*diffusion(j+1,sigma,mu,diff_flag)*np.eye(2)\n",
    "            size[:,j] = j+1\n",
    "            num_bound = np.random.default_rng().binomial(tend,(kon+kon1*j)/(kon+kon1*j+koff))\n",
    "            vb = np.random.default_rng().multivariate_normal(vc,cov,num_bound)\n",
    "            vu = np.random.default_rng().multivariate_normal(np.array([0,0]),cov,tend-num_bound)\n",
    "            v = np.concatenate((vb,vu))\n",
    "            velos[:,j,:] = v\n",
    "            state[0:num_bound,j] = 1\n",
    "            pe[:,j] = Pe(v,vc)\n",
    "            sp[:,j] = Sp(v,vc)\n",
    "            disp[:,j] = np.sqrt(np.sum(v**2))\n",
    "    elif model == 4:\n",
    "        for j in range(M):\n",
    "            cov = 2*diffusion(j+1,sigma,mu,diff_flag)*np.eye(2)\n",
    "            velo_coef = velocity_fluid_drag(j+1,mu)\n",
    "            size[:,j] = j+1\n",
    "            v = np.random.default_rng().multivariate_normal(velo_coef*vc,cov,tend)\n",
    "            velos[:,j,:] = v\n",
    "            pe[:,j] = Pe(v,vc)\n",
    "            sp[:,j] = Sp(v,vc)\n",
    "            disp[:,j] = np.sqrt(np.sum(v**2))\n",
    "\n",
    "    return pe, sp, velos, size, disp, state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f4f08ec6-46fb-4750-a11f-6cb9cb52efd1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_boxplots(out,M,models,pars,fname):\n",
    "    pe, sp, velos, size, disp, state = zip(*out)\n",
    "    pars_arr = np.array(pars)\n",
    "    colors = ['C0','C1','C2','C3']\n",
    "    Ynum = int(np.shape(pars_arr)[0]/4)\n",
    "    \n",
    "    labels = ['1-3','4-6','7-9','10-12']\n",
    "    groups = [(0,1,2),(3,4,5),(6,7,8),(9,10,11)]\n",
    "    expt = [1,1.25,1.5,1.75]\n",
    "\n",
    "    data = np.empty((len(models),len(groups),int(len(groups[0])*Ynum*500)))\n",
    "    for i in range(len(models)):\n",
    "        mod = models[i]\n",
    "        idx = (pars_arr[:,-1]==mod)\n",
    "\n",
    "        Y = np.array(pe)\n",
    "        for j in range(len(groups)):\n",
    "            data[i,j,:] = (Y[idx,:,groups[j][0]:groups[j][-1]+1].ravel())\n",
    "\n",
    "    fig, axes = plt.subplots(1,4, figsize=(6,2), sharey=True, constrained_layout=True)\n",
    "\n",
    "    for i in range(len(models)):\n",
    "        mod = models[i]\n",
    "        ax = axes[i]\n",
    "        bp = ax.boxplot(data[i,:].T,labels=labels,showfliers=False,patch_artist=True)\n",
    "        ax.set_xticklabels(labels)\n",
    "        ax.set_xlabel('Cluster Size')\n",
    "        ax.set_yticks(np.arange(0,6))\n",
    "        ax.set_ylim((0,5))\n",
    "\n",
    "        ax.plot(np.arange(1,5),expt,'ko:',zorder=10)\n",
    "\n",
    "        for patch in bp['boxes']:\n",
    "            patch.set_facecolor(colors[i])\n",
    "        for median in bp['medians']:\n",
    "            median.set_color('k')\n",
    "        ax.set_title('Model '+str(mod),fontsize=10)\n",
    "    axes[0].set_ylabel('Péclet Number')\n",
    "\n",
    "    fig.canvas.draw()\n",
    "    labels = ['A','B','C','D']\n",
    "    for ax, label in zip(axes, labels):\n",
    "        bbox = ax.get_tightbbox(fig.canvas.get_renderer())\n",
    "        fig.text(bbox.x0, bbox.y1, label,\n",
    "                 transform=None,va='top')\n",
    "\n",
    "    fig.savefig(fname+'.pdf',format='pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "03d11055-9fa8-4574-a359-e3d43cd24ff9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_lineplots(sizediff,constdiff,M,models,pars,fname):\n",
    "    \n",
    "    #size dependent diffusion\n",
    "    pe, sp, velos, size, disp, state = zip(*sizediff)\n",
    "    pars_arr = np.array(pars)\n",
    "    colors = ['C0','C1','C2','C3']\n",
    "    \n",
    "    M = 10 #UPDATE THIS TO BE MAX CLUSTER SIZE PLOTTED\n",
    "    x = np.arange(1,M+1)\n",
    "\n",
    "    fig, axes = plt.subplots(2,2, figsize=(5,4), sharex=True, constrained_layout=True)\n",
    "\n",
    "    for i in range(len(models)):\n",
    "        mod = models[i]\n",
    "        idx = (pars_arr[:,-1]==mod)\n",
    "\n",
    "        Yavg = np.empty(M)\n",
    "        Ystd = np.empty_like(Yavg)\n",
    "        Ynum = np.shape(pars_arr[idx,:])[0]\n",
    "\n",
    "        Y = np.array(pe)\n",
    "        for j in range(M):\n",
    "            Yavg[j] = np.mean(Y[idx,:,j].ravel())\n",
    "            Ystd[j] = np.std(Y[idx,:,j].ravel())\n",
    "\n",
    "        axes[0,0].fill_between(x = x,\n",
    "                            y1 = Yavg - Ystd/np.sqrt(Ynum),\n",
    "                            y2 = Yavg + Ystd/np.sqrt(Ynum),\n",
    "                            alpha = 0.3,\n",
    "                            color=colors[i])\n",
    "        axes[0,0].errorbar(x = x,\n",
    "                         y = Yavg,\n",
    "                         yerr = Ystd/np.sqrt(Ynum),\n",
    "                         color=colors[i],\n",
    "                         label=str(mod))\n",
    "\n",
    "        Y = np.array(sp)\n",
    "        for j in range(M):\n",
    "            Yavg[j] = np.mean(Y[idx,:,j].ravel())\n",
    "            Ystd[j] = np.std(Y[idx,:,j].ravel())\n",
    "\n",
    "        axes[0,1].fill_between(x = x,\n",
    "                            y1 = Yavg - Ystd/np.sqrt(Ynum),\n",
    "                            y2 = Yavg + Ystd/np.sqrt(Ynum),\n",
    "                            alpha = 0.3,\n",
    "                            color=colors[i])\n",
    "        axes[0,1].errorbar(x = x,\n",
    "                         y = Yavg,\n",
    "                         yerr = Ystd/np.sqrt(Ynum),\n",
    "                         color=colors[i],\n",
    "                         label=str(mod))\n",
    "        \n",
    "        \n",
    "    #size INdependent diffusion\n",
    "    pe, sp, velos, size, disp, state = zip(*constdiff)    \n",
    "    for i in range(len(models)):\n",
    "        mod = models[i]\n",
    "        idx = (pars_arr[:,-1]==mod)\n",
    "\n",
    "        Yavg = np.empty(M)\n",
    "        Ystd = np.empty_like(Yavg)\n",
    "        Ynum = np.shape(pars_arr[idx,:])[0]\n",
    "\n",
    "        Y = np.array(pe)\n",
    "        for j in range(M):\n",
    "            Yavg[j] = np.mean(Y[idx,:,j].ravel())\n",
    "            Ystd[j] = np.std(Y[idx,:,j].ravel())\n",
    "\n",
    "        axes[1,0].fill_between(x = x,\n",
    "                            y1 = Yavg - Ystd/np.sqrt(Ynum),\n",
    "                            y2 = Yavg + Ystd/np.sqrt(Ynum),\n",
    "                            alpha = 0.3,\n",
    "                            color=colors[i])\n",
    "        axes[1,0].errorbar(x = x,\n",
    "                         y = Yavg,\n",
    "                         yerr = Ystd/np.sqrt(Ynum),\n",
    "                         color=colors[i],\n",
    "                         label=str(mod))\n",
    "\n",
    "        Y = np.array(sp)\n",
    "        for j in range(M):\n",
    "            Yavg[j] = np.mean(Y[idx,:,j].ravel())\n",
    "            Ystd[j] = np.std(Y[idx,:,j].ravel())\n",
    "\n",
    "        axes[1,1].fill_between(x = x,\n",
    "                            y1 = Yavg - Ystd/np.sqrt(Ynum),\n",
    "                            y2 = Yavg + Ystd/np.sqrt(Ynum),\n",
    "                            alpha = 0.3,\n",
    "                            color=colors[i])\n",
    "        axes[1,1].errorbar(x = x,\n",
    "                         y = Yavg,\n",
    "                         yerr = Ystd/np.sqrt(Ynum),\n",
    "                         color=colors[i],\n",
    "                         label=str(mod))\n",
    "        \n",
    "    for ax in axes.ravel():\n",
    "        ax.set_xticks(np.arange(1,M+1))\n",
    "\n",
    "    for ax in axes[:,0]:\n",
    "        ax.set_ylabel('Péclet Number')\n",
    "        ax.set_ylim((0,4))\n",
    "        ax.set_yticks(np.linspace(0,4,5))\n",
    "    \n",
    "    for ax in axes[:,1]:\n",
    "        ax.set_ylabel('Scalar Projection')\n",
    "        ax.set_ylim((0,0.125))\n",
    "        ax.set_yticks(np.linspace(0,0.125,6))\n",
    "    \n",
    "    axes[0,0].legend(loc=2,ncol=2,title='Model')\n",
    "    \n",
    "    for ax in axes[1,:]:\n",
    "        ax.set_xlabel('Cluster Size')\n",
    "\n",
    "    labels = ['A','B','C','D']\n",
    "    fig.canvas.draw()\n",
    "    for ax, label in zip(axes.ravel(), labels):\n",
    "        bbox = ax.get_tightbbox(fig.canvas.get_renderer())\n",
    "        fig.text(bbox.x0, bbox.y1, label,\n",
    "                 transform=None,va='top')\n",
    "        \n",
    "    fig.savefig(fname+'.pdf',format='pdf')\n",
    "    \n",
    "def make_lineplots_v2(sizediff,constdiff,M,models,pars,fname):\n",
    "    \n",
    "    #size dependent diffusion\n",
    "    pe, sp, velos, size, disp, state = zip(*sizediff)\n",
    "    pars_arr = np.array(pars)\n",
    "    colors = ['C0','C1','C2','C3']\n",
    "    \n",
    "    M = 10 #UPDATE THIS TO BE MAX CLUSTER SIZE PLOTTED\n",
    "    x = np.arange(1,M+1)\n",
    "\n",
    "    fig = plt.figure(constrained_layout=True, figsize=(6,5))\n",
    "    subfigs = fig.subfigures(2, 1, wspace=0.07)\n",
    "    \n",
    "    axestop = subfigs[0].subplots(1,2)\n",
    "    axesbottom = subfigs[1].subplots(1,2)\n",
    "    \n",
    "    subfigs[0].set_facecolor('0.95')\n",
    "\n",
    "    for i in range(len(models)):\n",
    "        mod = models[i]\n",
    "        idx = (pars_arr[:,-1]==mod)\n",
    "\n",
    "        Yavg = np.empty(M)\n",
    "        Ystd = np.empty_like(Yavg)\n",
    "        Ynum = np.shape(pars_arr[idx,:])[0]\n",
    "\n",
    "        Y = np.array(pe)\n",
    "        for j in range(M):\n",
    "            Yavg[j] = np.mean(Y[idx,:,j].ravel())\n",
    "            Ystd[j] = np.std(Y[idx,:,j].ravel())\n",
    "\n",
    "        axestop[0].fill_between(x = x,\n",
    "                            y1 = Yavg - Ystd/np.sqrt(Ynum),\n",
    "                            y2 = Yavg + Ystd/np.sqrt(Ynum),\n",
    "                            alpha = 0.3,\n",
    "                            color=colors[i])\n",
    "        axestop[0].errorbar(x = x,\n",
    "                         y = Yavg,\n",
    "                         yerr = Ystd/np.sqrt(Ynum),\n",
    "                         color=colors[i],\n",
    "                         label=str(mod))\n",
    "\n",
    "        Y = np.array(sp)\n",
    "        for j in range(M):\n",
    "            Yavg[j] = np.mean(Y[idx,:,j].ravel())\n",
    "            Ystd[j] = np.std(Y[idx,:,j].ravel())\n",
    "\n",
    "        axestop[1].fill_between(x = x,\n",
    "                            y1 = Yavg - Ystd/np.sqrt(Ynum),\n",
    "                            y2 = Yavg + Ystd/np.sqrt(Ynum),\n",
    "                            alpha = 0.3,\n",
    "                            color=colors[i])\n",
    "        axestop[1].errorbar(x = x,\n",
    "                         y = Yavg,\n",
    "                         yerr = Ystd/np.sqrt(Ynum),\n",
    "                         color=colors[i],\n",
    "                         label=str(mod))\n",
    "        \n",
    "        \n",
    "    #size INdependent diffusion\n",
    "    pe, sp, velos, size, disp, state = zip(*constdiff)    \n",
    "    for i in range(len(models)):\n",
    "        mod = models[i]\n",
    "        idx = (pars_arr[:,-1]==mod)\n",
    "\n",
    "        Yavg = np.empty(M)\n",
    "        Ystd = np.empty_like(Yavg)\n",
    "        Ynum = np.shape(pars_arr[idx,:])[0]\n",
    "\n",
    "        Y = np.array(pe)\n",
    "        for j in range(M):\n",
    "            Yavg[j] = np.mean(Y[idx,:,j].ravel())\n",
    "            Ystd[j] = np.std(Y[idx,:,j].ravel())\n",
    "\n",
    "        axesbottom[0].fill_between(x = x,\n",
    "                            y1 = Yavg - Ystd/np.sqrt(Ynum),\n",
    "                            y2 = Yavg + Ystd/np.sqrt(Ynum),\n",
    "                            alpha = 0.3,\n",
    "                            color=colors[i])\n",
    "        axesbottom[0].errorbar(x = x,\n",
    "                         y = Yavg,\n",
    "                         yerr = Ystd/np.sqrt(Ynum),\n",
    "                         color=colors[i],\n",
    "                         label=str(mod))\n",
    "\n",
    "        Y = np.array(sp)\n",
    "        for j in range(M):\n",
    "            Yavg[j] = np.mean(Y[idx,:,j].ravel())\n",
    "            Ystd[j] = np.std(Y[idx,:,j].ravel())\n",
    "\n",
    "        axesbottom[1].fill_between(x = x,\n",
    "                            y1 = Yavg - Ystd/np.sqrt(Ynum),\n",
    "                            y2 = Yavg + Ystd/np.sqrt(Ynum),\n",
    "                            alpha = 0.3,\n",
    "                            color=colors[i])\n",
    "        axesbottom[1].errorbar(x = x,\n",
    "                         y = Yavg,\n",
    "                         yerr = Ystd/np.sqrt(Ynum),\n",
    "                         color=colors[i],\n",
    "                         label=str(mod))\n",
    "        \n",
    "    for ax in axestop.ravel():\n",
    "        ax.set_xticks(np.arange(1,M+1))\n",
    "        ax.set_xlabel('Cluster Size')\n",
    "\n",
    "    for ax in axesbottom.ravel():\n",
    "        ax.set_xticks(np.arange(1,M+1))\n",
    "        ax.set_xlabel('Cluster Size')\n",
    "        \n",
    "    for ax in [axestop[0],axesbottom[0]]:\n",
    "        ax.set_ylabel('Péclet Number')\n",
    "        ax.set_ylim((0,4))\n",
    "        ax.set_yticks(np.linspace(0,4,5))\n",
    "    \n",
    "    for ax in [axestop[1],axesbottom[1]]:\n",
    "        ax.set_ylabel('Scalar Projection')\n",
    "        ax.set_ylim((0,0.125))\n",
    "        ax.set_yticks(np.linspace(0,0.125,6))\n",
    "    \n",
    "    axestop[0].legend(loc=2,ncol=2,title='Model')\n",
    "    \n",
    "    axestop[0].text(-9/72, 1+2/72, 'A', transform=axestop[0].transAxes, va='top')\n",
    "    axestop[1].text(-17/72, 1+2/72, 'B', transform=axestop[1].transAxes, va='top')\n",
    "    axesbottom[0].text(-9/72, 1+2/72, 'C', transform=axesbottom[0].transAxes, va='top')\n",
    "    axesbottom[1].text(-17/72, 1+2/72, 'D', transform=axesbottom[1].transAxes, va='top')\n",
    "\n",
    "    subfigs[0].suptitle('Size-Dependent Diffusion',fontsize=10)\n",
    "    subfigs[1].suptitle('Size-Independent Diffusion',fontsize=10)\n",
    "    fig.savefig(fname+'.pdf',format='pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a0b91b5d-e16a-4719-a6be-6270a1e6dd6a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Plot Setup\n",
      "Simulating Size-Dependent Diffusion\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 4 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  42 tasks      | elapsed:    2.3s\n",
      "[Parallel(n_jobs=-1)]: Done 192 tasks      | elapsed:    9.1s\n",
      "[Parallel(n_jobs=-1)]: Done 400 out of 400 | elapsed:   20.4s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Simulating Size-Independent Diffusion\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 4 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  76 tasks      | elapsed:    4.1s\n",
      "[Parallel(n_jobs=-1)]: Done 376 tasks      | elapsed:   17.4s\n",
      "[Parallel(n_jobs=-1)]: Done 400 out of 400 | elapsed:   18.4s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Plotting Size-Dependent Diffusion\n",
      "Plotting Size-Independent Diffusion\n",
      "Plain Figure 4\n",
      "Fancy Figure 4\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x144 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x144 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x288 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x360 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print('Plot Setup')\n",
    "plot_setup()\n",
    "models = [1,2,3,4]\n",
    "M = 12\n",
    "\n",
    "if not (os.path.isfile('data/Fig3_Data.pkl') & os.path.isfile('data/Fig3_Data_ConstantDiff.pkl') & os.path.isfile('data/Fig3_ParamSets.pkl')):\n",
    "    #generate parameter sets\n",
    "    num_cells = 100\n",
    "    sigma = 0.01\n",
    "    mu_list = np.random.default_rng().uniform(0.05,0.2,num_cells)\n",
    "    kon_list = np.random.default_rng().uniform(0.1,10,num_cells)\n",
    "    kon1_list = np.random.default_rng().uniform(0,10,num_cells)\n",
    "    pars = [(*p,mod) for p in zip(mu_list,sigma*np.ones(num_cells),kon_list,kon1_list,M*np.ones(num_cells)) for mod in models]\n",
    "\n",
    "    with open('data/Fig3_ParamSets.pkl','wb') as f:\n",
    "        pickle.dump(pars,f)\n",
    "\n",
    "    \n",
    "    print('Simulating Size-Dependent Diffusion')\n",
    "    diff_flag = 1\n",
    "    sizediff = Parallel(n_jobs = -1, verbose = 1)(delayed(mc)(*p,diff_flag) for p in pars)\n",
    "\n",
    "    with open('data/Fig3_Data.pkl','wb') as f:\n",
    "        pickle.dump(sizediff,f)\n",
    "    \n",
    "    print('Simulating Size-Independent Diffusion')\n",
    "    diff_flag = 0\n",
    "    constdiff = Parallel(n_jobs = -1, verbose = 1)(delayed(mc)(*p,diff_flag) for p in pars)\n",
    "    \n",
    "    with open('data/Fig3_Data_ConstantDiff.pkl','wb') as f:\n",
    "        pickle.dump(constdiff,f)\n",
    "        \n",
    "with open('data/Fig3_Data.pkl','rb') as f:\n",
    "    sizediff = pickle.load(f)\n",
    "\n",
    "with open('data/Fig3_Data_ConstantDiff.pkl','rb') as f:\n",
    "    constdiff = pickle.load(f)\n",
    "    \n",
    "with open('data/Fig3_ParamSets.pkl','rb') as f:\n",
    "    pars = pickle.load(f)\n",
    "    \n",
    "print('Plotting Size-Dependent Diffusion')\n",
    "fname = 'figures/Fig3'\n",
    "make_boxplots(sizediff,M,models,pars,fname)\n",
    "\n",
    "\n",
    "print('Plotting Size-Independent Diffusion')\n",
    "fname = 'figures/Fig3_ConstDiff'\n",
    "make_boxplots(constdiff,M,models,pars,fname)\n",
    "\n",
    "print('Plain Figure 4')\n",
    "fname = 'figures/Fig4_notitles_nobackground'\n",
    "make_lineplots(sizediff,constdiff,M,models,pars,fname)\n",
    "\n",
    "\n",
    "print('Fancy Figure 4')\n",
    "fname = 'figures/Fig4'\n",
    "make_lineplots_v2(sizediff,constdiff,M,models,pars,fname)"
   ]
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}