{
"cells": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from fem_sol import frap_solver\n",
"from matplotlib import cm, rc, rcParams\n",
"from matplotlib.ticker import MaxNLocator\n",
"import fem_utils\n",
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"import pandas as pd\n",
"import seaborn as sns\n",
"from scipy.interpolate import interp1d\n",
"fol = '/Users/hubatsch/Desktop/DropletFRAP/Latex/Figures/'\n",
"# sns.set_style(\"ticks\")\n",
"rcParams['axes.linewidth'] = 0.75\n",
"rcParams['xtick.major.width'] = 0.75\n",
"rcParams['ytick.major.width'] = 0.75\n",
"# rcParams['text.usetex']=True"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Define colors\n",
"pa = sns.color_palette(\"Set2\")\n",
"sns.set_palette(pa)\n",
"grey = (0.6, 0.6, 0.6)\n",
"dark_grey = (0.2, 0.2, 0.2)\n",
"green = pa[0]\n",
"blue = pa[2]\n",
"red = pa[1]\n",
"pink = (233/255, 72/255, 119/255)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import pylab as pl\n",
"params = {'legend.fontsize': 9,\n",
" 'legend.handlelength': 1}\n",
"pl.rcParams.update(params)\n",
"\n",
"def nice_fig(xla, yla, xli, yli, size, fs=12): \n",
" rc('font',**{'family':'sans-serif','sans-serif':['Helvetica']})\n",
"# rc('font',**{'family':'serif','serif':['Palatino']})\n",
" plt.gcf().set_size_inches(size[0], size[1])\n",
" plt.xlabel(xla,fontsize=fs) \n",
" plt.ylabel(yla,fontsize=fs)\n",
" plt.xlim(xli)\n",
" plt.ylim(yli)\n",
" plt.tick_params(axis='both', which='major', labelsize=fs)\n",
"\n",
"def save_nice_fig(name, form='pdf', dpi=300):\n",
" plt.savefig(name, format=form, dpi=dpi, bbox_inches='tight',\n",
" transparent=True)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### FRAP geometries"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# For radial average: define angles and radial spacing\n",
"alphas = np.linspace(0,2*np.pi, 20)\n",
"ns = np.c_[np.cos(alphas), np.sin(alphas), np.zeros(len(alphas))]\n",
"eps = np.linspace(0, 0.23, 100)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Multi Drop"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"me = ['Meshes/multi_drop_gauss.xml', 'Meshes/multi_drop_gauss_med.xml',\n",
" 'Meshes/multi_drop_gauss_far.xml', 'Meshes/multi_drop_gauss.xml',\n",
" 'Meshes/multi_drop_gauss_med.xml', 'Meshes/multi_drop_gauss_far.xml']\n",
"point_lists = [[[4, 4.5, 0.25], [4, 3.5, 0.25], [3.5, 4, 0.25], [4.5, 4, 0.25]],\n",
" [[4, 5, 0.25], [4, 3, 0.25], [3, 4, 0.25], [5, 4, 0.25]],\n",
" [[4, 5.5, 0.25], [4, 2.5, 0.25], [2.5, 4, 0.25], [5.5, 4, 0.25]],\n",
" [[4, 4.5, 0.25], [4, 3.5, 0.25], [3.5, 4, 0.25], [4.5, 4, 0.25]],\n",
" [[4, 5, 0.25], [4, 3, 0.25], [3, 4, 0.25], [5, 4, 0.25]],\n",
" [[4, 5.5, 0.25], [4, 2.5, 0.25], [2.5, 4, 0.25], [5.5, 4, 0.25]]]\n",
"phi_tot_int = [.99, .99, .99, .9, .9, .9]\n",
"phi_tot_ext = [.01, .01, .01, .1, .1, .1]\n",
"G_in = [1, 1, 1, .1, .1, .1]\n",
"G_out = [1, 1, 1, 0.99/0.9, 0.99/0.9, 0.99/0.9]\n",
"\n",
"f_i = []\n",
"\n",
"for p, m, p_i, p_e, G_i, G_o in zip(point_lists, me, phi_tot_int,\n",
" phi_tot_ext, G_in, G_out):\n",
" f = frap_solver([4, 4, 0.25], m, name='FRAP_multi/FRAP_multi_'+m[:-4]+str(G_i), point_list=p,\n",
" T=240, dt=0.02, phi_tot_int=p_i, phi_tot_ext=p_e, G_in=G_i, G_out=G_o)\n",
"# f.solve_frap()\n",
" f_i.append(f)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"profs = []\n",
"for i in range(len(f_i)):\n",
"# if i>2:\n",
" profs.append([])\n",
" for j in range(240):\n",
" values=[]\n",
" fs = fem_utils.load_time_point(f_i[i].name+'t_p_'+str(j)+'.h5',\n",
" f_i[i].mesh)\n",
" print('Reading time point ' + str(j) + ' of simulation ' + str(i))\n",
" for n in ns:\n",
" values.append([fs([4, 4, 0.25]+e*n) for e in eps])\n",
" profs[i].append(np.mean(np.transpose(values), 1))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Write out profiles to .csv\n",
"for i in [0, 1, 2, 3, 4, 5]:\n",
" dist = str(point_lists[i][0][1]-4)\n",
" P = str(f_i[i].phi_tot_int/f_i[i].phi_tot_ext)\n",
" np.savetxt('eps_multi_'+str(i)+'.csv', eps, delimiter=',')\n",
" np.savetxt('t_p_multi_' + P + '_' + dist +'.csv',\n",
" profs[i][1:], delimiter=',')\n",
" meta_data = np.r_[f_i[i].dt, f_i[i].T-1, eps, 0.25] # last param: droplet radius\n",
" np.savetxt('meta_data_multi_' + P + '_' + dist + '.csv', meta_data, delimiter=',')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ft = f_i[1]\n",
"meta_data = np.r_[ft.dt, ft.T, eps]\n",
"np.savetxt('meta_data.csv', meta_data, delimiter=',')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"plt.plot(eps,np.transpose(profs)[:,:])"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"nice_fig('time $t$ [s]', 'intensity [a.u.]', [0,4], [0,1.05], [1.5,2])\n",
"plt.plot(np.linspace(0, (f_i[0].T-1)*f_i[0].dt, f_i[0].T), \n",
" [np.mean(x)/f_i[0].phi_tot_int for x in profs[0]],\n",
" lw=2, label='d=0.5', ls='-')\n",
"plt.plot(np.linspace(0, (f_i[1].T-1)*f_i[1].dt, f_i[1].T),\n",
" [np.mean(x)/f_i[1].phi_tot_int for x in profs[1]],\n",
" lw=2, label='d=1', ls='--')\n",
"plt.plot(np.linspace(0, (f_i[2].T-1)*f_i[2].dt, f_i[2].T),\n",
" [np.mean(x)/f_i[2].phi_tot_int for x in profs[2]],\n",
" lw=2, label='d=1.5', ls=':')\n",
"plt.plot(range(0, 100), np.ones(100), linestyle='--', color='k')\n",
"plt.title('$P=99}$', size=12)\n",
"plt.gca().get_yaxis().set_visible(False)\n",
"save_nice_fig(fol+'Fig3/tot_recov_neighbours_bad.pdf')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"nice_fig('time $t$ [s]', r'av. volume fraction $\\bar{\\phi}_\\mathrm{u}$', [0,4.], [0,1.05], [1.5,2])\n",
"plt.plot(np.linspace(0, (f_i[3].T-1)*f_i[3].dt, f_i[3].T),\n",
" [np.mean(x)/f_i[3].phi_tot_int for x in profs[3]],\n",
" lw=2, label='$d=0.5 \\,\\mathrm{\\mu m}$', ls='-')\n",
"plt.plot(np.linspace(0, (f_i[4].T-1)*f_i[4].dt, f_i[4].T),\n",
" [np.mean(x)/f_i[4].phi_tot_int for x in profs[4]],\n",
" lw=2, label='$d=1 \\,\\mathrm{\\mu m}$', ls='--')\n",
"plt.plot(np.linspace(0, (f_i[5].T-1)*f_i[5].dt, f_i[5].T),\n",
" [np.mean(x)/f_i[5].phi_tot_int for x in profs[5]],\n",
" lw=2, label='$d=1.5 \\,\\mathrm{\\mu m}$', ls=':')\n",
"plt.plot(range(0, 100), np.ones(100), linestyle='--', color='k')\n",
"plt.title('$P=9$', size=12)\n",
"plt.legend(prop={'size': 9}, frameon=False, loc=(0.2, 0.025),\n",
" handletextpad=0.4, labelspacing=0.2)\n",
"save_nice_fig(fol+'Fig3/tot_recov_neighbours_good.pdf')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ml = np.loadtxt('/Users/hubatsch/Desktop/DropletFRAP/matlab_fit_multi.csv',\n",
" delimiter=',')\n",
"nice_fig('radial distance $r$ [$\\mathrm{\\mu m}$]', 'volume fraction $\\phi_\\mathrm{u}$', [0,0.23], [0,1.05], [3.8,2])\n",
"l_sim = plt.plot(eps, np.transpose(profs[0])[:,1:181:22]/f_i[0].phi_tot_int, c=green,\n",
" lw=4.5, alpha=0.7)\n",
"plt.plot(range(0, 100), np.ones(100), linestyle='--', color='k')\n",
"l_fit = plt.plot(np.linspace(0, 0.23, 100), np.transpose(ml)[:,:180:22], c='k', lw=1.5)\n",
"plt.legend([l_sim[0], l_fit[0]], ['Model, eq. (6)', 'Fit, eq. (1)'], loc=(0.1, 0.77),\n",
" prop={'size': 9}, frameon=False, labelspacing=0.1, handlelength=0.1, ncol=2)\n",
"save_nice_fig(fol+'Fig3/spat_recov_neighbours.pdf')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Coverslip"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Define parameters for all simulations\n",
"point_list = [[4, 4, 0.25], [4, 4, 1.5], [4, 4, 4],\n",
" [4, 4, 0.25], [4, 4, 1.5], [4, 4, 4]]\n",
"me = ['coverslip.xml', '1_5.xml', 'symmetric.xml',\n",
" 'coverslip.xml', '1_5.xml', 'symmetric.xml']\n",
"phi_tot_int = [.99, .99, .99, .9, .9, .9]\n",
"phi_tot_ext = [.01, .01, .01, .1, .1, .1]\n",
"G_in = [1, 1, 1, .1, .1, .1]\n",
"G_out = [1, 1, 1, 0.99/0.9, 0.99/0.9, 0.99/0.9]\n",
"f_cs = []\n",
"\n",
"# Zip all parameters, iterate\n",
"for p, m, p_i, p_e, G_i, G_o, i in zip(point_list, me, phi_tot_int,\n",
" phi_tot_ext, G_in, G_out, range(len(me))):\n",
" if i in [0, 1, 2, 3, 4, 5]:\n",
" f_cs.append(frap_solver(p, 'Meshes/single_drop_'+m,\n",
" name='FRAP_coverslip/FRAP_'+m[:-4]+str(G_i), T=240,\n",
" phi_tot_int=p_i, dt=0.02, phi_tot_ext=p_e, G_in=G_i,\n",
" G_out=G_o))\n",
"# f_cs[-1].solve_frap()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"z = [0.25, 1.5, 4, 0.25, 1.5, 4]\n",
"\n",
"# eps = np.linspace(0, 3.5, 100) # for full profile\n",
"# eps = np.r_[np.linspace(0, 0.4, 100), np.linspace(0.41, 2, 20)]\n",
"eps = np.linspace(0, 0.23, 100)\n",
"profs_cs = []\n",
"for i, z_i in enumerate(z):\n",
" profs_cs.append([])\n",
" for j in range(240):\n",
" values=[]\n",
" fs = fem_utils.load_time_point(f_cs[i].name+\n",
" 't_p_'+str(j)+'.h5', f_cs[i].mesh)\n",
" for n in ns:\n",
" values.append([fs([4, 4, z_i]+e*n) for e in eps])\n",
" profs_cs[i].append(np.mean(np.transpose(values), 1))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Write out profiles to .csv\n",
"for i in [0, 1, 2, 3, 4, 5]:\n",
" z_str = str(f_cs[i].cent_poin[-1])\n",
" P = str(f_cs[i].phi_tot_int/f_cs[i].phi_tot_ext)\n",
" np.savetxt('eps_'+str(i)+'.csv', eps, delimiter=',')\n",
" np.savetxt('t_p_long_coverslip_' + P + '_' + z_str +'.csv',\n",
" profs_cs[i][1:], delimiter=',')\n",
" meta_data = np.r_[f_cs[i].dt, f_cs[i].T-1, eps, 0.25] # last param: droplet radius\n",
" np.savetxt('meta_data_long_coverslip_' + P + '_' + z_str + '.csv', meta_data, delimiter=',')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"nice_fig('time $t$ [s]', '', [0,4], [0,1.05], [1.5,2])\n",
"ls = ['-', '--', '-.']\n",
" \n",
"for i, f in enumerate(f_cs[0:3]):\n",
" plt.plot(np.linspace(0, (f.T-1)*f.dt, f.T),\n",
" [np.mean(x)/f.phi_tot_int for x in profs_cs[i]],\n",
" label='d='+str(z[i]), ls=ls[i], lw=2)\n",
"plt.plot(range(0, 100), np.ones(100), linestyle='--', color='k')\n",
"plt.title('$P=99$', size=12)\n",
"plt.gca().get_yaxis().set_visible(False)\n",
"save_nice_fig(fol+'Fig3/tot_recov_cs_bad.pdf')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"nice_fig('time $t$ [s]', r'av. volume fraction $\\bar{\\phi}_\\mathrm{u}$', [0,4], [0,1.05], [1.5,2])\n",
"ls = ['-', '--', '-.']\n",
"for i, f in enumerate(f_cs[3:]):\n",
" plt.plot(np.linspace(0, (f.T-1)*f.dt, f.T),\n",
" [np.mean(x)/f.phi_tot_int for x in profs_cs[i+3]],\n",
" label='$h=$'+str(z[i])+'$\\,\\mathrm{\\mu m}$', lw=2, ls=ls[i])\n",
"plt.plot(range(0, 100), np.ones(100), linestyle='--', color='k')\n",
"plt.title('$P=9$', size=12)\n",
"plt.legend(prop={'size': 9}, frameon=False, loc=(0.18, 0.025),\n",
" handletextpad=0.4, labelspacing=0.2)\n",
"save_nice_fig(fol+'Fig3/tot_recov_cs_good.pdf')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ml_neigh = np.loadtxt('/Users/hubatsch/Desktop/DropletFRAP/matlab_fit_coverslip.csv',\n",
" delimiter=',')\n",
"nice_fig('radial distance $r$ [$\\mathrm{\\mu m}$]', 'volume fraction $\\phi_\\mathrm{u}$', [0,0.23], [0,1.05], [3.8,2])\n",
"l_sim = plt.plot(eps, np.transpose(profs_cs[0])[:,1::22]/f_cs[0].phi_tot_int, c=green,\n",
" lw=4.5, alpha=0.7)\n",
"plt.plot(range(0, 100), np.ones(100), linestyle='--', color='k')\n",
"l_fit = plt.plot(np.linspace(0, 0.23, 100), np.transpose(ml_neigh)[:,::22],\n",
" ls='-', c='k', lw=1)\n",
"plt.legend([l_sim[0], l_fit[0]], ['Model, eq. (6)', 'Fit, eq. (1)'], frameon=False, loc=(0.1, 0.77), ncol=2)\n",
"save_nice_fig(fol+'Fig3/spat_recov_coverslip.pdf')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Figure 1: Fitting $D_{in}$ and data analysis."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Panel: comparison PGL-3 diffusivity with Louise's viscosity**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"louise = pd.read_csv('/Users/hubatsch/Desktop/DropletFRAP/Latex/Figures/Fig1/Louise.csv')\n",
"lars = pd.read_csv('/Users/hubatsch/Desktop/DropletFRAP/Latex/Figures/Fig1/Lars.csv')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Calculate rough molecular radius, based on Stokes-Einstein and Louise's\n",
"# viscosity data from the Science paper supplement (Fig. S5G), email from Louise:\n",
"# earliest point is 10.4 Pa*s .\n",
"# Einstein kinetic theory: D=kB*T/(6*pi*eta*r)\n",
"D = lars.D[lars.conc==75].mean()\n",
"eta = 10.4\n",
"kBT = 4.11*10**-21\n",
"r = kBT/(D*6*np.pi*eta)\n",
"print(r)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fig, ax1 = plt.subplots()\n",
"ax2 = ax1.twinx()\n",
"plt.sca(ax1)\n",
"nice_fig('c_\\mathrm{salt} [\\mathrm{mM}]', '$\\eta^{-1} \\;[Pa\\cdot s]^{-1}$', [40,190], [0,7.24], [2.3,2])\n",
"sns.lineplot(x=\"conc\", y=\"D\", data=lars, color=sns.color_palette()[1])\n",
"sns.scatterplot(x=\"conc\", y=\"D\", data=lars, color=sns.color_palette()[1], alpha=0.8)\n",
"plt.xlabel('$c_\\mathrm{salt}\\; [\\mathrm{mM}]$')\n",
"plt.ylabel('$D_{\\mathrm{in}} \\;[\\mathrm{\\mu m^2\\cdot s^{-1}}]$', color=red)\n",
"plt.yticks([0, 0.05, 0.1], rotation=90, color = pa[1])\n",
"plt.ylim(0, 0.1)\n",
"ax1.set_zorder(1) \n",
"ax1.patch.set_visible(False)\n",
"plt.sca(ax2)\n",
"sns.lineplot(x=\"conc\", y=\"vis\", data=louise, color=grey, label='data from Jawerth \\net al. 2018')\n",
"plt.yticks(color = grey, fontsize=12)\n",
"plt.ylabel('$\\eta^{-1} \\;[\\mathrm{Pa\\cdot s}]^{-1}$ ', color = grey, fontsize=12)\n",
"plt.legend(frameon=False, fontsize=9)\n",
"# save_nice_fig(fol+'Fig1/Lars_vs_Louise.pdf')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ratio between $D_{out}$ for maximum and minimum salt concentrations for PGL-3**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"lars[lars.conc==180].mean()/lars[lars.conc==50].mean()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Panel:coacervates PLYS/ATP, CMD/PLYS**m"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"coacervates = pd.read_csv('/Users/hubatsch/Desktop/DropletFRAP/Latex/Figures/Fig1/Coacervates.csv')\n",
"sns.stripplot(data=coacervates, palette=[green, blue], jitter=0.35,**{'marker': '.', 'size': 10})\n",
"ax = sns.barplot(data=coacervates, palette=pa, facecolor=(1, 1, 1, 0), edgecolor=[pa[0], pa[2]], capsize=.15, ci='sd', errwidth=1.5)\n",
"plt.setp(ax.lines, zorder=100)\n",
"nice_fig(None, '$D_\\mathrm{in} \\;[\\mathrm{\\mu m^2\\cdot s^{-1}}]$', [None, None], [0,7], [2.3,2])\n",
"plt.xticks([0,1], ('CMD/PLYS', 'PLYS/ATP'), rotation=20)\n",
"ax.get_xticklabels()[0].set_color(green)\n",
"ax.get_xticklabels()[1].set_color(blue)\n",
"plt.xlim(-0.7, 1.7)\n",
"# save_nice_fig(fol+'Fig1/Coacervates.pdf')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Panel: time course CMD**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"CMD = np.loadtxt(fol+'/Fig1/CMD_timecourse_D.csv', delimiter=',')\n",
"CMD_fit = np.loadtxt(fol+'/Fig1/CMD_fit_timecourse_D.csv', delimiter=',')\n",
"l_sim = plt.plot(CMD[:, 0], CMD[:, 1::40], '.', c=green)\n",
"l_fit = plt.plot(CMD_fit[:, 0], CMD_fit[:, 1::40], '-', lw=1, c='k')\n",
"plt.plot(range(0, 10), np.ones(10)*np.min(CMD_fit[:, 1]), linestyle='--', color=grey, lw=1.5)\n",
"plt.legend([l_sim[0], l_fit[0]], ['data', 'fit'], ncol=2, loc=(0, 0.85), frameon=False)\n",
"nice_fig('radial distance $r$ [$\\mathrm{\\mu m}$]', 'intensity [a.u.]', [0,np.max(CMD_fit[:, 0])], [0,0.65], [2.3,2])\n",
"# save_nice_fig(fol+'Fig1/CMD_spat_recov.pdf')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Panel: time course PLYS**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"PLYS = np.loadtxt(fol+'/Fig1/PLYS_timecourse_D.csv', delimiter=',')\n",
"PLYS_fit = np.loadtxt(fol+'/Fig1/PLYS_fit_timecourse_D.csv', delimiter=',')\n",
"l_sim = plt.plot(PLYS[:, 0], PLYS[:, 1::40], '.', c=blue)\n",
"l_fit = plt.plot(PLYS_fit[:, 0], PLYS_fit[:, 1::40], '-', lw=1, c='k')\n",
"plt.plot(range(0, 10), np.ones(10)*np.min(PLYS_fit[:, 1]), linestyle='--', color=grey, lw=1.5)\n",
"plt.legend([l_sim[0], l_fit[0]], ['data', 'fit'], ncol=2, loc=(0, 0.85), frameon=False)\n",
"nice_fig('radial distance $r$ [$\\mathrm{\\mu m}$]', 'intensity [a.u.]', [0,np.max(PLYS_fit[:, 0])], [0,0.79], [2.3,2])\n",
"save_nice_fig(fol+'Fig1/PLYS_spat_recov.pdf')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Panel: time course PGL-3**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"PGL = np.loadtxt(fol+'/Fig1/PGL_timecourse_D.csv', delimiter=',')\n",
"PGL_fit = np.loadtxt(fol+'/Fig1/PGL_fit_timecourse_D.csv', delimiter=',')\n",
"l_sim = plt.plot(PGL[:, 0], PGL[:, 1::130], '.', c=red)\n",
"l_fit = plt.plot(PGL_fit[:, 0], PGL_fit[:, 1::130], '-', lw=1, c='k')\n",
"plt.plot(range(0, 10), np.ones(10)*np.min(PGL_fit[:, 1]), linestyle='--', color=grey, lw=1.5)\n",
"plt.legend([l_sim[0], l_fit[0]], ['data', 'fit'], ncol=2, loc=(0.015, 0.865), frameon=False)\n",
"nice_fig('radial distance $r$ [$\\mathrm{\\mu m}$]', 'intensity [a.u.]', [0,np.max(PGL_fit[:, 0])], [0, 0.65], [2.3,2])\n",
"save_nice_fig(fol+'Fig1/PGL_spat_recov.pdf')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"l_sim = plt.plot(PGL[:, 0], PGL[:, 1], '-', c=red)\n",
"nice_fig('', '', [0,np.max(PGL_fit[:, 0])], [0, 0.55], [0.7,0.7], fs=5)\n",
"plt.yticks([0, 0.5], ['', ''])\n",
"plt.xticks([0, 3], ['', ''])\n",
"plt.gca().tick_params(direction='in', length=3, width=1)\n",
"save_nice_fig(fol+'Fig1/PGL_spat_90.pdf')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"l_sim = plt.plot(PGL[:, 0], PGL[:, 4*80], '-', c=red)\n",
"nice_fig('', '', [0,np.max(PGL_fit[:, 0])], [0, 0.55], [0.7,0.7], fs=5)\n",
"plt.yticks([0, 0.5], ['', ''])\n",
"plt.xticks([0, 3], ['', ''])\n",
"plt.gca().tick_params(direction='in', length=3, width=1)\n",
"save_nice_fig(fol+'Fig1/PGL_spat_300.pdf')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"l_sim = plt.plot(PGL[:, 0], PGL[:, 7*80], '-', c=red)\n",
"nice_fig('', '', [0,np.max(PGL_fit[:, 0])], [0, 0.55], [0.7,0.7], fs=5)\n",
"plt.yticks([0, 0.5], ['', ''])\n",
"plt.xticks([0, 3], ['', ''])\n",
"plt.gca().tick_params(direction='in', length=3, width=1)\n",
"save_nice_fig(fol+'Fig1/PGL_spat_510.pdf')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Supplement: movie PLYS**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"PLYS = np.loadtxt(fol+'/Fig1/PLYS_timecourse_D.csv', delimiter=',')\n",
"PLYS_fit = np.loadtxt(fol+'/Fig1/PLYS_fit_timecourse_D.csv', delimiter=',')\n",
"CMD = np.loadtxt(fol+'/Fig1/CMD_timecourse_D.csv', delimiter=',')\n",
"CMD_fit = np.loadtxt(fol+'/Fig1/CMD_fit_timecourse_D.csv', delimiter=',')\n",
"PGL = np.loadtxt(fol+'/Fig1/PGL_timecourse_D.csv', delimiter=',')\n",
"PGL_fit = np.loadtxt(fol+'/Fig1/PGL_fit_timecourse_D.csv', delimiter=',')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"zipped = zip([PLYS, CMD, PGL], [PLYS_fit, CMD_fit, PGL_fit],\n",
" [blue, green, red], ['PLYS/ATP', 'CMD/PLYS', 'PGL-3'],\n",
" [0.9, 0.7, 0.8])\n",
"for mov, mov_fit, c, l, yl in zipped:\n",
" for i in range(np.shape(mov)[1]-1):\n",
" l_sim = plt.plot(mov[:, 0], mov[:, 1+i], '-', c=c)\n",
" l_fit = plt.plot(mov_fit[:, 0], mov_fit[:, 1+i], '-', lw=1, c='k')\n",
" plt.plot(range(0, 10), np.ones(10)*np.min(mov_fit[:, 1]), linestyle='--', color=grey, lw=1.5)\n",
" plt.legend([l_sim[0], l_fit[0]], [l, 'Fit to Eq. (1)'], ncol=2, loc=(0, 0.85), frameon=False,\n",
" columnspacing=0.8, handletextpad=0.5, handlelength=0.65)\n",
" nice_fig('radial distance $r$ [$\\mathrm{\\mu m}$]', 'intensity [a.u.]', [0,np.max(mov_fit[:, 0])], [0, yl], [2.3,2])\n",
" plt.yticks([0.2, 0.4, 0.6])\n",
" if l=='PLYS/ATP':\n",
" plt.yticks([0.2, 0.4, 0.6, 0.8])\n",
" save_nice_fig(fol+'Fig4/Movies/'+l[:3]+'_spat_recov_mov_'+str(i)+'.png', form='png', dpi=149.5)\n",
" plt.show();"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Panel: time course total intensity**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"PGL = np.loadtxt(fol+'/Fig1/PGL_bc.csv', delimiter=',')\n",
"ATP = np.loadtxt(fol+'/Fig1/ATP_bc.csv', delimiter=',')\n",
"CMD = np.loadtxt(fol+'/Fig1/CMD_bc.csv', delimiter=',')\n",
"# fig, ax1 = plt.subplots()\n",
"# ax2 = ax1.twiny()\n",
"# plt.sca(ax1)\n",
"nice_fig('$t/T_\\mathrm{max}$', 'intensity [a.u.]', [0,200], [0,0.62], [2.3,2])\n",
"# plt.sca(ax2)\n",
"# ax2.tick_params(axis=\"x\",direction=\"in\")\n",
"plt.plot(PGL[::10, 0]/np.max(PGL[1:-1:2, 0]), PGL[::10,1], '.', label='PGL-3', c='#CC406E', markersize=3, alpha=0.7, lw=2)\n",
"plt.plot(ATP[::1, 0]/np.max(ATP[:, 0]), ATP[::1,1], '.', label='PLYS/ATP', c='#FF508A', markersize=3, alpha=0.7, lw=2)\n",
"plt.plot(CMD[::5, 0]/np.max(CMD[:, 0]), CMD[::5,1], '.', label='CMD/PLYS', c='#7F2845', markersize=3, alpha=0.7, lw=2)\n",
"plt.legend(frameon=False, fontsize=9)\n",
"plt.xlim(0, 1)\n",
"# save_nice_fig(fol+'Fig1/tot_recov.pdf')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"PGL = []\n",
"for i in range(8):\n",
" PGL.append(np.loadtxt(fol+'/Fig1/PGL_bc'+str(i+1)+'.csv', delimiter=','))\n",
"conc = np.loadtxt(fol+'/Fig1/PGL_conc.csv', delimiter=',')\n",
"rads = [25, 24, 29, 26, 25, 53, 33, 26]\n",
"# PGL = [PGL[i] for i in [0, 1, 2, 3, 4, 5, 7]]\n",
"# rads = "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"nice_fig('time $t$ [s]', 'boundary intensity', [0,140], [0,0.82], [1,2])\n",
"temp = sns.color_palette()\n",
"sns.set_palette(sns.color_palette(\"rocket\", 9))\n",
"# plt.sca(ax2)\n",
"# ax2.tick_params(axis=\"x\",direction=\"in\")\n",
"# plt.plot(PGL[::10, 0], PGL[::10,1], '.', label='PGL-3', c='#CC406E', markersize=3, alpha=0.7, lw=2)\n",
"for jj, i in enumerate(PGL):\n",
" if jj != 10:\n",
" plt.plot(i[::, 0]/(0.136*rads[jj])**2, i[::,1], '-', color=sns.color_palette()[jj], lw=1.5)\n",
"plt.legend([str(x)[:-2] for x in conc], columnspacing=0.2, frameon=False,\n",
" fontsize=7, handletextpad=0.4, handlelength=0.5, labelspacing=0.1,\n",
" loc=(0.3, 0), ncol=2) \n",
"# plt.xticks([0, 500])\n",
"# save_nice_fig(fol+'Fig1/tot_recov_PGL.pdf')\n",
"sns.set_palette(temp)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"PGL_bc_ill = np.loadtxt(fol+'/Fig1/PGL_bc_illustr.csv', delimiter=',')\n",
"plt.plot(PGL_bc_ill[:, 0], PGL_bc_ill[:, 1], c=pink)\n",
"nice_fig('', 'intensity', [0,150], [0,0.55], [2.3,0.75], fs=9)\n",
"plt.xticks([0, 150])\n",
"plt.tick_params(axis='x', which='major', pad=1)\n",
"save_nice_fig(fol+'Fig1/PGL_bc_ill.pdf')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"nice_fig('time $t$ [s]', 'intensity [a.u.]', [0,10], [0,0.72], [1,2])\n",
"plt.plot(ATP[::1, 0], ATP[::1,1], '-', label='PLYS/ATP', c=blue, markersize=3, alpha=0.7, lw=1.5)\n",
"plt.plot(CMD[::5, 0], CMD[::5,1], '-', label='CMD/PLYS', c=green, markersize=3, alpha=0.7, lw=1.5)\n",
"plt.legend(frameon=False, fontsize=7, loc=(0.1, 0), handletextpad=0.5)\n",
"plt.yticks([]); plt.ylabel('')\n",
"save_nice_fig(fol+'Fig1/tot_recov_coac.pdf')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Valley in cost function**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"PGL_cost = np.loadtxt(fol+'/Fig1/PGL_cost.csv', delimiter=',')\n",
"plt.plot(PGL_cost[:, 0], 100000*PGL_cost[:, 1], c=red)\n",
"nice_fig('$D_\\mathrm{in} \\;[\\mathrm{\\mu m^2\\cdot s^{-1}}]$', '$cost$ [a.u.]', [0.8,1.5], [0,5.5], [2.3,2], fs=12)\n",
"plt.xticks([1, 1.2, 1.4])\n",
"plt.tick_params(axis='x', which='major', pad=1)\n",
"plt.legend(['Sample PGL-3 droplet'], loc=(0, 0.85), frameon=False)\n",
"# save_nice_fig(fol+'Fig1/PGL_cost.pdf')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Figure 2: model sketches"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"model = np.loadtxt(fol+'Fig2/model_timecourse.csv', delimiter=',')\n",
"l_fit = plt.plot(model[:, 0], model[:, 1:], '-', lw=1,\n",
" c=green, label='Simulation')\n",
"nice_fig('radial distance $r/R$', 'volume fraction $\\phi_\\mathrm{u}$', [0, 2],\n",
" [0,1], [2.3,2])\n",
"plt.plot(model[:, 0], model[:, -1], c=green, lw=2)\n",
"plt.plot(model[:, 0], model[:, -1], 'k', lw=2)\n",
"# plt.annotate('$t \\longrightarrow \\infty$', (0.97, 0.89), (1.3,0.85), fontsize=12)\n",
"# plt.annotate('$t \\longrightarrow \\infty$', (0.97, 0.89), (1.3,0.85), fontsize=12)\n",
"plt.annotate('$\\phi_\\mathrm{tot}$', (1, 0.5), (1.5,0.5), fontsize=10)\n",
"save_nice_fig(fol+'Fig2/full_time_course.pdf')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"l_fit = plt.plot(model[:, 0], model[:, 2], '-', lw=1,\n",
" c=dark_grey, label='Simulation')\n",
"plt.plot(model[:, 0], model[:, -1], 'k', lw=2)\n",
"nice_fig('radial distance $r/R$', 'volume fraction $\\phi_\\mathrm{u}$', [0, 2],\n",
" [0,1], [2.3,2])\n",
"plt.title('$t=0.22 \\;R^2/D_\\mathrm{in}$')\n",
"plt.text(0.75, 0.18, '$\\phi_\\mathrm{u}$', fontsize=10)\n",
"plt.gca().fill_between(model[:, 0], 0, model[:, 2], color=green)\n",
"plt.gca().fill_between(model[:, 0], model[:, -1], model[:, 2], color=grey)\n",
"plt.annotate('$\\phi_\\mathrm{tot}$', (1, 0.5), (1.5,0.5), fontsize=10)\n",
"save_nice_fig(fol+'Fig2/snap_shot.pdf')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"l_fit = plt.plot(model[:, 0], model[:, 1], '-', lw=1,\n",
" c=dark_grey, label='Simulation')\n",
"plt.plot(model[:, 0], model[:, -1], 'k', lw=2)\n",
"nice_fig('radial distance $r/R$', 'volume fraction $\\phi_\\mathrm{u}$', [0, 2],\n",
" [0,1], [2.3,2])\n",
"plt.title('$t=0.22 \\;R^2/D_\\mathrm{in}$')\n",
"plt.text(1.45, 0.02, '$\\phi_\\mathrm{u}$', fontsize=10)\n",
"plt.gca().fill_between(model[:, 0], 0, model[:, -1], color=green)\n",
"plt.gca().fill_between(model[:, 0], model[:, -1], model[:, 1], color=grey)\n",
"plt.annotate('$\\phi_\\mathrm{tot}$', (1, 0.5), (1.5,0.5), fontsize=10)\n",
"save_nice_fig(fol+'Fig2/snap_shot_bleach.pdf')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"l_fit = plt.plot(model[:, 0], model[:, -2], '-', lw=1,\n",
" c=dark_grey, label='Simulation')\n",
"plt.plot(model[:, 0], model[:, -1], 'k', lw=2)\n",
"nice_fig('radial distance $r/R$', 'volume fraction $\\phi_\\mathrm{u}$', [0, 2],\n",
" [0,1], [2.3,2])\n",
"plt.title('$t=0.22 \\;R^2/D_\\mathrm{in}$')\n",
"plt.text(0.47, 0.4, '$\\phi_\\mathrm{u}$', fontsize=10)\n",
"plt.gca().fill_between(model[:, 0], 0, model[:, -2], color=green)\n",
"plt.gca().fill_between(model[:, 0], model[:, -2], model[:, -1], color=grey)\n",
"plt.annotate('$\\phi_\\mathrm{tot}$', (1, 0.5), (1.5,0.5), fontsize=10)\n",
"save_nice_fig(fol+'Fig2/snap_shot_late.pdf')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# l_fit = plt.plot(model[:, 0], model[:, -2], '-', lw=1,\n",
"# c=dark_grey, label='Simulation')\n",
"plt.plot(model[:, 0], model[:, -1], 'k', lw=2)\n",
"nice_fig('radial distance $r/R$', 'volume fraction $\\phi_\\mathrm{u}$', [0, 2],\n",
" [0,1], [2.3,2])\n",
"plt.title('$t=0.22 \\;R^2/D_\\mathrm{in}$')\n",
"plt.text(0.47, 0.4, '$\\phi_\\mathrm{u}$', fontsize=10)\n",
"plt.gca().fill_between(model[:, 0], 0, model[:, -1], color=green)\n",
"plt.annotate('$\\phi_\\mathrm{tot}$', (1, 0.5), (1.5,0.5), fontsize=10)\n",
"save_nice_fig(fol+'Fig2/snap_shot_before.pdf')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Figure 4: Obtaining info about outside: experiments."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Panel: data time course with full model.**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"CMD = np.loadtxt(fol+'Fig4/CMD_timecourse.csv', delimiter=',')\n",
"CMD_fit = np.loadtxt(fol+'Fig4/CMD_fit_timecourse.csv', delimiter=',')\n",
"CMD_t = np.loadtxt(fol+'Fig4/CMD_fit_time.csv', delimiter=',')\n",
"l_data = plt.plot(CMD[:, 0], CMD[:, 1::30], c=green, lw=2,\n",
" label='Experiment')\n",
"l_fit = plt.plot(CMD_fit[:, 0], CMD_fit[:, 2::30], '-', lw=1,\n",
" c=dark_grey, label='Simulation')\n",
"l_fit = plt.plot(CMD_fit[:, 0], CMD_fit[:, 1], '-', lw=1,\n",
" c=dark_grey) # Initial condition\n",
"nice_fig('radial distance $r$ [$\\mathrm{\\mu m}$]', 'intensity [a.u.]',\n",
" [0, 2.4*np.max(CMD[:, 0])], [0,0.7], [2.3,2])\n",
"plt.legend([l_data[0], l_fit[0]], ['CMD/PLYS', 'Full model'], frameon=False,\n",
" fontsize=9, handletextpad=0.4, handlelength=0.8, loc=(0.52, 0.7))\n",
"save_nice_fig(fol+'Fig4/CMD_spat_recov_new.pdf')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"PLYS = np.loadtxt(fol+'Fig4/PLYS_timecourse.csv', delimiter=',')\n",
"PLYS_fit = np.loadtxt(fol+'Fig4/PLYS_fit_timecourse.csv', delimiter=',')\n",
"PLYS_t = np.loadtxt(fol+'Fig4/PLYS_fit_time.csv', delimiter=',')\n",
"l_data = plt.plot(PLYS[:, 0], PLYS[:, 1::30], c=blue, lw=2)\n",
"l_fit = plt.plot(PLYS_fit[:, 0], PLYS_fit[:, 2::30], '-', lw=1,\n",
" c=dark_grey, label='Simulation') # time course\n",
"l_fit = plt.plot(PLYS_fit[:, 0], PLYS_fit[:, 1], '-', lw=1,\n",
" c=dark_grey) # Initial condition\n",
"nice_fig('radial distance $r$ [$\\mathrm{\\mu m}$]', 'intensity [a.u.]',\n",
" [0, 2.4*np.max(PLYS[:, 0])], [0,0.75], [2.3,2])\n",
"plt.legend([l_data[0], l_fit[0]], ['PLYS/ATP', 'Full model'], frameon=False,\n",
" fontsize=9, handletextpad=0.4, handlelength=0.8, loc=(0.52, 0.7))\n",
"save_nice_fig(fol+'Fig4/PLYS_spat_recov_new.pdf')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"PGL = np.loadtxt(fol+'Fig4/PGL_timecourse.csv', delimiter=',')\n",
"PGL_fit = np.loadtxt(fol+'Fig4/PGL_fit_timecourse.csv', delimiter=',')\n",
"PGL_t = np.loadtxt(fol+'Fig4/PGL_fit_time.csv', delimiter=',')\n",
"l_data = plt.plot(PGL[:, 0], PGL[:, 1::140], c=red, lw=2,\n",
" label='Experiment')\n",
"l_fit = plt.plot(PGL_fit[:, 0], PGL_fit[:, 2::140], '-', lw=1,\n",
" c=dark_grey, label='Simulation')\n",
"plt.plot(PGL_fit[:, 0], PGL_fit[:, 1], '-', lw=1, c=dark_grey)\n",
"nice_fig('radial distance $r$ [$\\mathrm{\\mu m}$]', 'intensity [a.u.]',\n",
" [0, 2.7*np.max(PGL[:, 0])], [0,0.7], [2.3,2])\n",
"plt.legend([l_data[0], l_fit[0]], ['PGL-3', 'Full model'],\n",
" frameon=False, fontsize=9, handletextpad=0.4,\n",
" handlelength=0.8, loc=(0.54, 0.7))\n",
"save_nice_fig(fol+'Fig4/PGL_spat_recov.pdf')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"zipped = zip([PLYS, CMD, PGL], [PLYS_fit, CMD_fit, PGL_fit],\n",
" [PLYS_t, CMD_t, PGL_t], [blue, green, red],\n",
" ['PLYS/ATP', 'CMD/PLYS', 'PGL-3'], [0.9, 0.7, 0.8])\n",
"for (mov, mov_fit, mov_t, c, l, yl) in zipped:\n",
" for i in range(np.shape(mov)[1]-1):\n",
" l_data = plt.plot(mov[:, 0], mov[:, 1+i], c=c, lw=2)\n",
" l_fit = plt.plot(mov_fit[:, 0], mov_fit[:, 2+i], '-', lw=1,\n",
" c=dark_grey) # time course\n",
" nice_fig('radial distance $r$ [$\\mathrm{\\mu m}$]', 'intensity [a.u]',\n",
" [0, 2.7*np.max(mov[:, 0])], [0, yl], [2.35,2.005])\n",
" plt.legend([l_data[0], l_fit[0]], [l, 'Fit to Eq. (6)'], frameon=False,\n",
" fontsize=9, handletextpad=0.4, handlelength=0.8, loc=(0.48, 0.7))\n",
" t = str(np.round(mov_t[i+1], 2))\n",
" plt.text(0.5, yl-0.11/0.8*yl, t.ljust(4, '0') + ' s')\n",
" plt.yticks([0.2, 0.4, 0.6])\n",
" if l=='PLYS/ATP':\n",
" plt.yticks([0.2, 0.4, 0.6, 0.8])\n",
" save_nice_fig(fol+'Fig4/Movies/'+l[:3]+'_spat_recov_model_'+str(i)+'.png',\n",
" form='png', dpi=149)\n",
" plt.show();"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Panel: Experimental Partition coefficient vs $D_{out}$ for CMD**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"PLYS = pd.read_csv('/Users/hubatsch/Desktop/DropletFRAP/Latex/Figures/Fig4/PLYS.csv')\n",
"CMD = pd.read_csv('/Users/hubatsch/Desktop/DropletFRAP/Latex/Figures/Fig4/CMD.csv')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fig, ax1 = plt.subplots()\n",
"plt.sca(ax1)\n",
"sns.lineplot(x=\"P\", y=\"D_out\", data=CMD, color=green, ci='sd')\n",
"sns.lineplot(x=\"P\", y=\"D_out\", data=PLYS, color=blue, ci='sd')\n",
"plt.plot(np.logspace(1, 3, 10), 1.5*np.logspace(1, 3, 10), '--', c='grey', alpha=0.5)\n",
"# plt.plot(np.logspace(0, 2, 10), 0.2*np.logspace(0, 2, 10)**2, '--', c='grey')\n",
"ax1.set_yscale('log')\n",
"ax1.set_xscale('log')\n",
"nice_fig('Partition coefficient $P$', '$D_\\mathrm{out} \\;[\\mathrm{\\mu m^2s^{-1}}]$',\n",
" [1,340], [0.08,450], [2.3,2])\n",
"plt.legend(['CMD/PLYS', 'PLYS/ATP'], frameon=False, fontsize=9, loc=(0.44,0.05))\n",
"plt.text(1.1, 2, '$D_\\mathrm{in, P/A}$', color=blue)\n",
"plt.text(1.1, 7, '$D_\\mathrm{in, C/P}$', color=green)\n",
"# plt.plot([1, 9], [1.7, 1.7], '--', color=blue)\n",
"# plt.plot([1, 12], [6, 6], '--', color=green)\n",
"plt.xticks([1, 10, 100]);\n",
"plt.yticks([0.1, 1, 10, 100]);\n",
"save_nice_fig(fol+'Fig4/PLYS_CMD.pdf')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Panel: Experimental Partition coefficient vs $D_out$ for PGL-3**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"PGL_50 = pd.read_csv('/Users/hubatsch/Desktop/DropletFRAP/Latex/Figures/Fig4/PGL_50.csv')\n",
"PGL_60 = pd.read_csv('/Users/hubatsch/Desktop/DropletFRAP/Latex/Figures/Fig4/PGL_60.csv')\n",
"PGL_75 = pd.read_csv('/Users/hubatsch/Desktop/DropletFRAP/Latex/Figures/Fig4/PGL_75.csv')\n",
"PGL_90 = pd.read_csv('/Users/hubatsch/Desktop/DropletFRAP/Latex/Figures/Fig4/PGL_90.csv')\n",
"PGL_100 = pd.read_csv('/Users/hubatsch/Desktop/DropletFRAP/Latex/Figures/Fig4/PGL_100.csv')\n",
"PGL_120 = pd.read_csv('/Users/hubatsch/Desktop/DropletFRAP/Latex/Figures/Fig4/PGL_120.csv')\n",
"PGL_150 = pd.read_csv('/Users/hubatsch/Desktop/DropletFRAP/Latex/Figures/Fig4/PGL_150.csv')\n",
"PGL_180 = pd.read_csv('/Users/hubatsch/Desktop/DropletFRAP/Latex/Figures/Fig4/PGL_180.csv')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fig, ax1 = plt.subplots()\n",
"plt.sca(ax1)\n",
"temp = sns.color_palette()\n",
"sns.set_palette(sns.color_palette(\"rocket\", 9))\n",
"l50 = sns.lineplot(x=\"P\", y=\"D_out\", data=PGL_50,\n",
" color=sns.color_palette()[1], ci=None)\n",
"l60 = sns.lineplot(x=\"P\", y=\"D_out\", data=PGL_60,\n",
" color=sns.color_palette()[2], ci=None)\n",
"l75 = sns.lineplot(x=\"P\", y=\"D_out\", data=PGL_75,\n",
" color=sns.color_palette()[3], ci=None)\n",
"l90 = sns.lineplot(x=\"P\", y=\"D_out\", data=PGL_90,\n",
" color=sns.color_palette()[4], ci=None)\n",
"l100 = sns.lineplot(x=\"P\", y=\"D_out\", data=PGL_100,\n",
" color=sns.color_palette()[5], ci=None)\n",
"ls = plt.gca().get_lines()\n",
"leg1 = plt.legend([ls[4], ls[3], ls[2], ls[1], ls[0]], ['100 mM', '90 mM', '75 mM', '60 mM', '50 mM'],\n",
" labelspacing=0.3, loc=(0.63, 0.0),\n",
" handletextpad=0.4, handlelength=0.5, frameon=0)\n",
"\n",
"l120 = sns.lineplot(x=\"P\", y=\"D_out\", data=PGL_120,\n",
" color=sns.color_palette()[6], ci=None)\n",
"l150 = sns.lineplot(x=\"P\", y=\"D_out\", data=PGL_150,\n",
" color=sns.color_palette()[7], ci=None)\n",
"l180 = sns.lineplot(x=\"P\", y=\"D_out\", data=PGL_180,\n",
" color=sns.color_palette()[8], ci=None)\n",
"plt.plot(np.logspace(0, 4, 10), 0.07*np.logspace(0, 4, 10),\n",
" '--', c='grey', alpha=0.5)\n",
"# plt.plot(np.logspace(2, 3, 10), 30*np.ones(10), '--', c='m', lw=2)\n",
"ax1.set_yscale('log')\n",
"ax1.set_xscale('log')\n",
"nice_fig('Partition coefficient $P$',\n",
" '$D_\\mathrm{out} \\;[\\mathrm{\\mu m^2 s^{-1}}]$',\n",
" [1,20000], [0.0003,600], [2.3,2])\n",
"plt.xticks([1, 10, 100, 1000, 10000]);\n",
"plt.legend(loc=1)\n",
"ls = plt.gca().get_lines()\n",
"plt.legend([ls[7], ls[6],ls[5]], ['180 mM', '150 mM', '120 mM'], labelspacing=0.3,\n",
" loc=(0, 0.66), handletextpad=0.4, handlelength=0.5, frameon=0)\n",
"plt.gca().add_artist(leg1)\n",
"# save_nice_fig(fol+'Fig4/PGL-3.pdf')\n",
"sns.set_palette(temp)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"le_egfp = 239\n",
"le_pgl3 = 693\n",
"ratio = le_egfp/(le_egfp+le_pgl3)\n",
"D_factor = np.sqrt(ratio)\n",
"D_GFPw = 87 # micron^2/s, Arrio-Dupont et al. 2000 BJ, GFP in water\n",
"D = D_GFPw*np.sqrt(ratio)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"P_anatol = np.array([686, 533, 590, 474])/np.array([1.6, 5.5, 7.5, 19.3])\n",
"salt_anatol = np.array([100, 150, 175, 200])\n",
"P = PGL_50['P']\n",
"def i_P(df, Pa):\n",
" return interp1d(np.array(df.groupby('P').mean()).flatten(),\n",
" P.unique())(Pa)\n",
"Ps_2 = [i_P(PGL, 2) for PGL in [PGL_50, PGL_60, PGL_75, PGL_90,\n",
" PGL_100, PGL_120, PGL_150, PGL_180]]\n",
"Ps_10 = [i_P(PGL, 10) for PGL in [PGL_50, PGL_60, PGL_75, PGL_90,\n",
" PGL_100, PGL_120, PGL_150, PGL_180]]\n",
"Ps_50 = [i_P(PGL, 50) for PGL in [PGL_50, PGL_60, PGL_75, PGL_90,\n",
" PGL_100, PGL_120, PGL_150, PGL_180]]\n",
"salts = [50, 60, 75, 90, 100, 120, 150, 180]\n",
"nice_fig('$c_\\mathrm{salt} \\; [\\mathrm{mM}]$', 'Partition coefficient $P$',\n",
" [50, 180], [12,20000], [2.3,2])\n",
"plt.plot(salts, Ps_2, color=red, label='$D_{\\mathrm{out}}=2$')\n",
"plt.plot(salts, Ps_10, color=green, label='$D_{\\mathrm{out}}=10$')\n",
"plt.plot(salts, Ps_50, color=blue, label='$D_{\\mathrm{out}}=50$')\n",
"# plt.plot(salt_anatol, P_anatol)\n",
"# plt.gca().fill_between(salts, Ps_15, Ps_30, color=red, alpha=0.2)\n",
"plt.yticks(rotation=45)\n",
"plt.yscale('log')\n",
"plt.legend(frameon=False, ncol=2, columnspacing=0.2, handletextpad=0.1,\n",
" labelspacing=0.2, loc=(0.005, -0.02), handlelength=0.5)\n",
"# plt.text(110, 6200, '$D_\\mathrm{out}=30\\;\\mathrm{\\mu m^2/s}$',\n",
"# color=red, size=8)\n",
"# plt.text(54, 700, '$D_\\mathrm{out}=15\\;\\mathrm{\\mu m^2/s}$',\n",
"# color=red, size=8)\n",
"# save_nice_fig(fol+'Fig4/PGL-3_part.pdf')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"P = PGL_50['P']\n",
"def i_P(df, Pa):\n",
" return interp1d(np.array(df.groupby('P').mean()).flatten(),\n",
" P.unique())(Pa)\n",
"\n",
"# def i_P_std(df, Pa):\n",
"# return interp1d(np.array(df.groupby('P').std()).flatten(),\n",
"# P.unique())(Pa)\n",
"Ps_10 = [i_P(PGL, 10) for PGL in [PGL_50, PGL_60, PGL_75, PGL_90,\n",
" PGL_100, PGL_120, PGL_150, PGL_180]]\n",
"# Ps_10_std = [i_P_std(PGL, 10) for PGL in [PGL_50, PGL_60, PGL_75, PGL_90,\n",
"# PGL_100, PGL_120, PGL_150, PGL_180]]\n",
"salts = [50, 60, 75, 90, 100, 120, 150, 180]\n",
"salts = [50, 60, 75, 90, 100, 120, 150, 180]\n",
"nice_fig('$c_\\mathrm{salt} \\; [\\mathrm{mM}]$', '$P$ / $P(c_\\mathrm{salt}=50mM)$',\n",
" [50, 180], [0,1], [2.3,2])\n",
"# plt.plot(salts, Ps_2/Ps_2[0], color=red, label='$D_{\\mathrm{out}}=2$')\n",
"plt.plot(salts, Ps_10/Ps_10[0], color=green, label='$D_{\\mathrm{out}}=10$')\n",
"# plt.plot(salts, Ps_50/Ps_50[0], color=blue, label='$D_{\\mathrm{out}}=50$')\n",
"plt.yticks(rotation=45)\n",
"# plt.yscale('log')\n",
"# plt.legend(frameon=False, ncol=2, columnspacing=0.2, handletextpad=0.1,\n",
"# labelspacing=0.2, loc=(0.005, -0.02), handlelength=0.5)\n",
"save_nice_fig(fol+'Fig4/PGL-3_relative_part.pdf')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Figure 5: Obtaining info about outside: theory."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Panel: Partition coefficient vs. $D_{out}$, showcasing four different simulation start cases.**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"sns.set_palette(sns.color_palette(\"Set2\"))\n",
"P_Do = np.loadtxt(fol+'/Fig4/Part_vs_Do_220121.csv', delimiter=',')\n",
"sns.set_style(\"white\")\n",
"sns.set_palette([sns.color_palette()[i] for i in [3, 0, 1, 2]])\n",
"P = [5, 150, 5, 150]\n",
"D_o = [0.1, 0.1, 1, 1]\n",
"plt.gca().set_prop_cycle(None)\n",
"nice_fig('Partition coefficient $P$', '$D_\\mathrm{out}$ [$\\mathrm{\\mu m^2/s}$]', [0.9,320], [0.000001,340], [2.3,2])\n",
"lines = plt.loglog(P_Do[0, :], P_Do[1:, :].transpose())\n",
"plt.plot(P_Do[0, :], P_Do[0, :], '--', c='grey')\n",
"# plt.legend([lines[2], lines[0], lines[3], lines[1]],\n",
"# ['0.2', '0.02', '0.0067', '0.00067'], ncol=2, frameon=False,\n",
"# title=r'$D_\\mathrm{out}$/P [$\\mathrm{\\mu m^2/s}$]:', columnspacing=0.5, labelspacing=0.3,\n",
"# loc=(0.4, 0), handletextpad=0.4, handlelength=0.5)\n",
"plt.gca().set_prop_cycle(None)\n",
"lines[0] = plt.plot(P[0], D_o[0], 'o', mfc='none', markersize=8)\n",
"lines[1] = plt.plot(P[1], D_o[1], 'o', mfc='none', markersize=8)\n",
"lines[2] = plt.plot(P[2], D_o[2], 'o', mfc='none', markersize=8)\n",
"lines[3] = plt.plot(P[3], D_o[3], 'o', mfc='none', markersize=8)\n",
"def circle(i):\n",
" return plt.Line2D(range(1), range(1), color=sns.color_palette()[i],\n",
" marker='o', markersize=5, markerfacecolor=\"white\")\n",
"plt.legend([circle(2), circle(0), circle(3), circle(1)],\n",
" ['0.2', '0.02', '0.0067', '0.00067'], ncol=2, frameon=False,\n",
" title=r'$D_\\mathrm{out}$/P [$\\mathrm{\\mu m^2/s}$]:', columnspacing=0.5, labelspacing=0.3,\n",
" loc=(0.4, 0), handletextpad=0.4, handlelength=0.5)\n",
"plt.annotate('$D_{out}$/P = 1 $\\mathrm{\\mu m^2/s}$', [1,40], c='grey')\n",
"plt.xticks([1, 10, 100]);\n",
"save_nice_fig(fol+'Fig4/D_vs_P.pdf')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Panel: Cost function**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"P_Cost = np.loadtxt(fol+'/Fig4/Part_vs_Cost_220121.csv', delimiter=',')\n",
"nice_fig('Partition coefficient $P$', '$Cost_\\mathrm{min} (P)$ [a.u.]', [0.9,320], [0.000000001,0.01], [2.3,2])\n",
"lines = plt.loglog(P_Cost[0, :], P_Cost[1:, :].transpose())\n",
"# plt.legend([lines[2], lines[0], lines[3], lines[1]],\n",
"# ['0.2', '0.02', '0.0067', '0.00067'], ncol=2, frameon=False,\n",
"# title=r'$D_\\mathrm{out}$/P set to:', columnspacing=0.5, labelspacing=0.3,\n",
"# loc=(0.081, 0), handletextpad=0.4, handlelength=0.5)\n",
"plt.xticks([1, 10, 100]);\n",
"# save_nice_fig(fol+'Fig4/D_vs_Cost.pdf')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"P_Cost = np.loadtxt(fol+'/Fig4/Part_vs_Cost_220121.csv', delimiter=',')\n",
"nice_fig('Partition coefficient $P$', '$Cost_\\mathrm{min} (P)$ [a.u.]', [0.9,100], [0,2], [2.3,2])\n",
"lines = plt.plot(P_Cost[0], P_Cost[1:].transpose()/[x[0] for x in P_Cost[1:]])\n",
"plt.gca().set_xscale('log')\n",
"plt.plot([150, 150], [0, 1], '--', lw=2, c=grey)\n",
"# save_nice_fig(fol+'Fig4/D_vs_Cost_single.pdf')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Panel: Valley in parameter space**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"con = np.loadtxt(fol+'Fig4/Valley_220121.csv', delimiter=',')\n",
"levels = MaxNLocator(nbins=100).tick_values(np.log10(con[:, 2:].min()), np.log10(con[:, 2:].max()))\n",
"nice_fig('Partition coefficient $P$', '$D_\\mathrm{out} \\;[\\mathrm{\\mu m^2 s^{-1}}]$', [1, 3], [-2,1], [2.3,2])\n",
"CS = plt.contourf(np.log10(con[:, 0]), np.log10(con[:, 1]), np.log10(con[:, 2:]), levels=levels, cmap=cm.coolwarm)\n",
"plt.plot(np.log10(150), np.log10(10**-1), 'o', c=sns.color_palette()[1], label='Reference Simulation', mfc='none', markersize=8)\n",
"le = plt.legend(loc=(0, 0.83), frameon=False, handletextpad=0.2)\n",
"# plt.plot(np.log10(P_Do[0, :]), np.log10(P_Do[2, :].transpose()), '--', c=green, lw = 1)\n",
"le.get_texts()[0].set_color('white')\n",
"plt.xticks([1, 2, 3], ['$10^1$', '$10^2$', '$10^3$'])\n",
"plt.yticks([-2, -1, 0, 1], ['$10^{-2}$', '$10^{-1}$', '$10^0$', '$10^1$'])\n",
"plt.tick_params('x', pad=5)\n",
"fig1 = plt.gcf()\n",
"clb = fig1.colorbar(CS, ticks=[0, -2, -4, -6])\n",
"clb.ax.set_title('Cost')\n",
"save_nice_fig(fol+'Fig4/Sim_D_out_P.pdf')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Panel: Zoom in for valley in parameter space**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# levels = MaxNLocator(nbins=15).tick_values(np.log10(con[:, 2:].min()), np.log10(con[:, 2:].max()))\n",
"nice_fig('Partition coefficient $P$', '', [1.9, 2.4], [-1.5,-0.5], [2.3,2])\n",
"CS = plt.contourf(np.log10(con[16:-27, 0]), np.log10(con[16:-27, 1]),\n",
" np.log10(con[16:-27, 2+16:-27]), levels=levels,\n",
" cmap=cm.coolwarm, vmax=-1.5)\n",
"plt.plot(np.log10(150), np.log10(10**-1), 'd', c=sns.color_palette()[1], label='Initial Simul.', markersize=6)\n",
"le = plt.legend(loc=(0, 0.83), frameon=False, handletextpad=0.4)\n",
"le.get_texts()[0].set_color('white')\n",
"plt.xticks([2, 2.25], ['$10^2$', '$10^{2.25}$'])\n",
"plt.yticks([-1.5, -1, -0.5], ['$10^{-1.5}$', '$10^{-1}$', '$10^{-0.5}$'])\n",
"plt.tick_params('x', pad=5)\n",
"fig1 = plt.gcf()\n",
"clb = fig1.colorbar(CS, ticks=[-2, -4, -6])\n",
"clb.ax.set_title('Cost')\n",
"# save_nice_fig(fol+'Fig4/Sim_D_out_P_inset.pdf')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"con_fine = np.loadtxt(fol+'Fig4/Valley_fine_210121.csv', delimiter=',')\n",
"# nice_fig('Partition coefficient $P$', '', [2.172, 2.1795], [-1.005,-0.9955], [2.3,2])\n",
"P = np.log10(con_fine[:,0])\n",
"D_o = np.log10(con_fine[:,1])\n",
"fval = np.log10(con_fine[:,2])\n",
"# levels = np.linspace(-fval.max(), -fval.min(), 100)\n",
"levels = MaxNLocator(nbins=50).tick_values(fval.min(), fval.max())\n",
"plt.plot(np.log10(150), np.log10(10**-1), 'd', c=sns.color_palette()[1], label='Initial Simul.', markersize=6)\n",
"cs = plt.tricontourf(P, D_o, -fval, levels=np.flip(-levels))\n",
"plt.yticks([-1.005, -1, -0.996], ['$10^{-1.005}$', '$10^{-1}$', '$10^{-0.996}$'], rotation=30)\n",
"plt.xticks([2.173, 2.178], ['$10^{2.173}$', '$10^{2.178}$'])\n",
"plt.tick_params(axis='x',direction='out', which='minor', length=10)\n",
"fig1 = plt.gcf()\n",
"clb = fig1.colorbar(cs, ticks=[5, 7, 9, 11])\n",
"clb.ax.set_title('Cost')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Figure: supplement. Scaling at early and late times"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"scal1 = np.loadtxt('scaling_test_1.csv', delimiter=',')\n",
"scal2 = np.loadtxt('scaling_test_2.csv', delimiter=',')\n",
"scal3 = np.loadtxt('scaling_test_3.csv', delimiter=',')\n",
"s1 = plt.plot(scal1[:, 0], scal1[:, 14::2], '-', lw=1, c=dark_grey)\n",
"s2 = plt.plot(scal2[:, 0], scal2[:, 14::2], '-', lw=1, c=red, alpha=0.3)\n",
"s3 = plt.plot(scal3[:, 0], scal3[:, 14::2], '-', lw=1, c=green)\n",
"nice_fig('radial distance $r$ [$\\mathrm{\\mu m}$]', 'intensity [a.u]',\n",
" [0, 2], [0,1], [3,2])\n",
"plt.legend([s1[0], s2[0], s3[0]], ['Reference', '$D_\\mathrm{out}\\propto P^2$',\n",
" '$D_\\mathrm{out}\\propto P$'], frameon=False,\n",
" fontsize=9, handletextpad=0.4, handlelength=0.8, loc=(0.57, 0.5))\n",
"save_nice_fig(fol+'Supp/scal_late.pdf')\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"s1 = plt.plot(scal1[:, 0], scal1[:, 14::2], '-', lw=1, c=dark_grey)\n",
"s2 = plt.plot(scal2[:, 0], scal2[:, 14::2], '-', lw=1, c=red, alpha=0.3)\n",
"s3 = plt.plot(scal3[:, 0], scal3[:, 14::2], '-', lw=1, c=green)\n",
"nice_fig('radial distance $r$ [$\\mathrm{\\mu m}$]', 'intensity [a.u]',\n",
" [0, 1.2], [0.35,1], [3,2])\n",
"save_nice_fig(fol+'Supp/scal_late_zoom.pdf')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"s1 = plt.plot(scal1[:, 0], scal1[:, 2:10:2], '-', lw=1, c=dark_grey)\n",
"s2 = plt.plot(scal2[:, 0], scal2[:, 2:10:2], '-', lw=1, c=red)\n",
"s3 = plt.plot(scal3[:, 0], scal3[:, 2:10:2], '-', lw=1, c=green, alpha=0.4)\n",
"nice_fig('radial distance $r$ [$\\mathrm{\\mu m}$]', 'intensity [a.u]',\n",
" [0, 2], [0,1], [3,2])\n",
"plt.legend([s1[0], s2[0], s3[0]], ['Reference', '$D_\\mathrm{out}\\propto P^2$',\n",
" '$D_\\mathrm{out}\\propto P$'], frameon=False,\n",
" fontsize=9, handletextpad=0.4, handlelength=0.8, loc=(0.57, 0.54))\n",
"save_nice_fig(fol+'Supp/scal_early.pdf')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"s1 = plt.plot(scal1[:, 0], scal1[:, 4:11:2], '-', lw=1, c=dark_grey, label='Original')\n",
"s2 = plt.plot(scal2[:, 0], scal2[:, 4:11:2], '-', lw=1, c=red, label='Original')\n",
"s3 = plt.plot(scal3[:, 0], scal3[:, 4:11:2], '-', lw=1, c=green, label='Original', alpha=0.4)\n",
"nice_fig('radial distance $r$ [$\\mathrm{\\mu m}$]', 'intensity [a.u]',\n",
" [0.97,1.03], [0, 0.35], [3,2])\n",
"save_nice_fig(fol+'Supp/scal_early_zoom.pdf')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"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.2"
}
},
"nbformat": 4,
"nbformat_minor": 4
}