Figures eLife.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "\n",
    "Plot figures of Descheemaeker & de Buyl, 2020 (DOI: 10.7554/eLife.55650)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Standard imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-27T15:25:58.113752Z",
     "start_time": "2020-08-27T15:25:57.261304Z"
    }
   },
   "outputs": [],
   "source": [
    "# Data manipulation\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "# Options for pandas\n",
    "pd.options.display.max_columns = 50\n",
    "pd.options.display.max_rows = 30\n",
    "\n",
    "from IPython import get_ipython\n",
    "ipython = get_ipython()\n",
    "\n",
    "# autoreload extension\n",
    "if 'autoreload' not in ipython.extension_manager.loaded:\n",
    "    %load_ext autoreload\n",
    "\n",
    "%autoreload 2\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import gridspec\n",
    "%matplotlib inline\n",
    "\n",
    "import time\n",
    "np.random.seed(int(time.time()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Specific imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-27T15:25:59.441473Z",
     "start_time": "2020-08-27T15:25:58.494672Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "load sglv_timeseries\n",
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "from noise_properties_plotting import noise_cmap_ww, noise_lim\n",
    "%matplotlib inline\n",
    "\n",
    "import sys\n",
    "sys.path.insert(1, '../sglv_timeseries')\n",
    "\n",
    "from sglv_timeseries.glv.Timeseries import Timeseries\n",
    "from sglv_timeseries.noise_parameters import NOISE\n",
    "from sglv_timeseries.models import MODEL\n",
    "\n",
    "from sglv_timeseries.timeseries_plotting import PlotTimeseries, PlotRankAbundance\n",
    "\n",
    "#from neutral_covariance_test import *\n",
    "\n",
    "from noise_analysis import noise_color\n",
    "from scipy import stats\n",
    "from scipy.optimize import curve_fit\n",
    "from neutrality_analysis import KullbackLeibler_neutrality\n",
    "from neutral_covariance_test import neutral_covariance_test\n",
    "\n",
    "# code for plotting\n",
    "from noise_properties_plotting import PiecewiseNormalize\n",
    "\n",
    "import matplotlib\n",
    "\n",
    "%load_ext autoreload\n",
    "\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Figure settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-27T15:25:59.553566Z",
     "start_time": "2020-08-27T15:25:59.443521Z"
    }
   },
   "outputs": [],
   "source": [
    "from elife_settings import set_elife_settings, ELIFE\n",
    "\n",
    "set_elife_settings()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-27T15:25:59.597521Z",
     "start_time": "2020-08-27T15:25:59.556053Z"
    }
   },
   "outputs": [],
   "source": [
    "## Figure functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-27T15:25:59.701461Z",
     "start_time": "2020-08-27T15:25:59.660712Z"
    }
   },
   "outputs": [],
   "source": [
    "def noise_colorbar_ax(ax):\n",
    "    x = np.linspace(0.9, -3, 500).reshape([500,1])\n",
    "    \n",
    "    ax.imshow(x, cmap=noise_cmap_ww, vmin = noise_lim[0], vmax= noise_lim[1], \n",
    "              extent=(0, 1, -3, 0.9), aspect='auto', alpha=0.75)\n",
    "    ax.set_ylabel('Noise color')\n",
    "    ax.set_xticks([])\n",
    "    ax.yaxis.set_label_position(\"right\")\n",
    "    ax.yaxis.tick_right()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Figures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Figure 1: Overview experimental data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-27T15:26:00.315799Z",
     "start_time": "2020-08-27T15:26:00.203992Z"
    }
   },
   "outputs": [],
   "source": [
    "data_path = 'Data/'\n",
    "\n",
    "def load_experimental_data():\n",
    "    # Load dataframes\n",
    "\n",
    "    # MartinPlatero plankton data\n",
    "\n",
    "    df_ts = {}\n",
    "\n",
    "    path = 'MartinPlatero/'\n",
    "    files = ['41467_2017_2571_MOESM5_ESM_MartinPlatero_Plankton_Eukarya.csv',\n",
    "             '41467_2017_2571_MOESM4_ESM_MartinPlatero_Plankton_Bacteria.csv']\n",
    "    keys = ['plankton_eukarya', 'plankton_bacteria'] \n",
    "\n",
    "    for i, f in enumerate(files):\n",
    "        x = pd.read_csv(data_path+path+f, na_values='NAN', index_col=0)\n",
    "        x = x.iloc[:, :-1] # delete last columns which contains details on the otu's\n",
    "\n",
    "        # only keep 200 most abundant species\n",
    "        sum_x = x.sum(axis='columns')\n",
    "\n",
    "        x = x[sum_x >= np.sort(sum_x)[-200]]\n",
    "\n",
    "        x = x.T # species are in rows instead of columns\n",
    "\n",
    "        x.insert(0, 'time', [int(j[4:7]) for j in x.index]) # day\n",
    "\n",
    "        x = x.groupby('time').agg('mean').reset_index()\n",
    "\n",
    "        x.columns = ['time'] + ['species_%d' % j for j in range(1, len(x.columns))]\n",
    "\n",
    "        df_ts[keys[i]] = x\n",
    "\n",
    "\n",
    "    # David stool data\n",
    "\n",
    "    files = [data_path + 'Faust/25_timeseries/25_timeseries.txt']\n",
    "    keys = ['David_stool_A']\n",
    "\n",
    "    for i, f in enumerate(files):\n",
    "        x = pd.read_csv(f, na_values='NAN', delimiter='\\t', header=None)\n",
    "\n",
    "        x = x.T\n",
    "\n",
    "        x.insert(0, 'time', range(len(x)))\n",
    "\n",
    "        x.columns = ['time'] + ['species_%d' % j for j in range(1, len(x.columns))]\n",
    "\n",
    "        df_ts[keys[i]] = x\n",
    "\n",
    "    # Caporaso body sites data\n",
    "\n",
    "    sites = ['F4_L_palm_L6', 'F4_tongue_L6']\n",
    "\n",
    "    for site in sites:\n",
    "        file = data_path + 'Caporaso/' + site + '.txt'\n",
    "        key = 'Caporaso_' + site\n",
    "\n",
    "        x = pd.read_csv(file, delimiter='\\t', skiprows=1, index_col=0, header=None)\n",
    "        \n",
    "        x.index = ['time'] + ['species_%d' % j for j in range(1, len(x.index))]\n",
    "\n",
    "        x = x.T\n",
    "\n",
    "        # only keep 200 most abundant species\n",
    "        if len(x.columns) > 201:\n",
    "            sum_x = x.sum(axis='rows')\n",
    "\n",
    "            sum_x['time'] = np.inf\n",
    "\n",
    "            sum_x.sort_values(ascending=False, inplace=True)\n",
    "\n",
    "            x = x[sum_x.index.tolist()[:201]]\n",
    "\n",
    "        x.columns = ['time'] + ['species_%d' % j for j in range(1, len(x.columns))]\n",
    "\n",
    "        df_ts[key] = x\n",
    "    return df_ts\n",
    "\n",
    "def calculate_noise_color(df_ts, keys=['plankton_eukarya', 'David_stool_A',\n",
    "            'Caporaso_F4_L_palm_L6', 'Caporaso_F4_tongue_L6']):\n",
    "    # calculate noise color\n",
    "    df_ns = {}\n",
    "\n",
    "    for i, key in enumerate(keys):\n",
    "        ts = df_ts[key]\n",
    "        ns = noise_color(ts)\n",
    "        df_ns[key] = ns['slope_linear']\n",
    "        df_ns[key + '_std'] = ns['std_slope_linear']\n",
    "    return df_ns\n",
    "\n",
    "def calculate_width_distribution(df_ts, keys=['plankton_eukarya', 'David_stool_A',\n",
    "            'Caporaso_F4_L_palm_L6', 'Caporaso_F4_tongue_L6']):\n",
    "    # calculate width distribution\n",
    "\n",
    "    df_disdx = {}\n",
    "\n",
    "    def fit_ratio(x):\n",
    "        x = x[:-1] / x[1:] # ratios of succesive time points\n",
    "        x = x[np.isfinite(x)] # remove infinities\n",
    "        x = x[x>0]\n",
    "\n",
    "        if len(x) > 5:\n",
    "            a, b, c = stats.lognorm.fit(x, floc=0)  # Gives the paramters of the fit\n",
    "            stat, pval = stats.kstest(x, 'lognorm', args=((a, b, c))) # get pvalue for kolmogorov-smirnov test \n",
    "            # (null hypothesis: ratios of succesive time points follow lognorm distribution)\n",
    "            \n",
    "            #nbins = 15                                                                                                                                                                                                                                                                                                                                                                                                                                             \n",
    "            #n, bins = np.histogram(x, nbins, density=True)       \n",
    "\n",
    "            #centers = (0.5*(bins[1:]+bins[:-1]))\n",
    "\n",
    "            #pars, cov = curve_fit(lambda x, a, b, c : \n",
    "            #                      stats.lognorm.pdf(x,a,b,c), \n",
    "            #                      centers, n, p0=[a,b,c])  \n",
    "\n",
    "            #ax.plot(centers, norm.pdf(centers,*pars), 'k--',linewidth = 2, label='fit before')                                                                                                                                                                                 \n",
    "            #ax.set_title('$\\mu={:.4f}\\pm{:.4f}$, $\\sigma={:.4f}\\pm{:.4f}$'.format(pars[0],np.sqrt(cov[0,0]), pars[1], np.sqrt(cov[1,1 ])))                                                                                                                                                                              \n",
    "\n",
    "            return a, b, c, stat, pval, np.nan #cov[0,0]\n",
    "        else:\n",
    "            return (np.nan, np.nan, np.nan, np.nan, np.nan, np.nan)\n",
    "\n",
    "    count = 0\n",
    "\n",
    "    for i, key in enumerate(keys):\n",
    "        ts = df_ts[key]\n",
    "\n",
    "        dx_ratio = pd.DataFrame(index=ts.columns, columns=['s', 'loc', 'scale', 'ks-stat', 'ks-pval', 's_std'])\n",
    "        dx_ratio.drop('time', inplace=True)\n",
    "\n",
    "        for idx in dx_ratio.index:\n",
    "            fit_par = fit_ratio(ts[idx].values)\n",
    "            dx_ratio.loc[idx] = fit_par\n",
    "\n",
    "            if False and fit_par[-1] > 0.5 and count < 10:\n",
    "                print(key, idx, fit_par[-1])\n",
    "\n",
    "                print(x[:5])\n",
    "\n",
    "                x = ts[idx].values\n",
    "                x_transf = x[:-1] / x[1:] # ratios of succesive time points\n",
    "                x_transf = x_transf[np.isfinite(x_transf)] # remove infinities\n",
    "\n",
    "                a, b, c, _, pval = fit_par\n",
    "\n",
    "                x_fit = np.logspace(-1.5,1.5,100)\n",
    "                pdf_fitted = stats.lognorm.pdf(x_fit,a,b,c) #Gives the PDF\n",
    "                plt.figure()\n",
    "                plt.hist(x_transf, alpha=0.4, normed=True, bins = np.logspace(-1.5,1.5,30))\n",
    "                plt.plot(x_fit, pdf_fitted, label='%.2f, %.2f, %.2f'%(a,b,c))\n",
    "                plt.xscale('log')\n",
    "                plt.legend()\n",
    "                plt.show()\n",
    "\n",
    "                count += 1\n",
    "\n",
    "        if count == 10:\n",
    "            break;\n",
    "\n",
    "        df_disdx[key] = dx_ratio\n",
    "    \n",
    "    return df_disdx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-27T15:26:09.683243Z",
     "start_time": "2020-08-27T15:26:00.382522Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:99: RuntimeWarning: divide by zero encountered in true_divide\n",
      "/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:99: RuntimeWarning: invalid value encountered in true_divide\n"
     ]
    }
   ],
   "source": [
    "df_ts = load_experimental_data()\n",
    "df_ns = calculate_noise_color(df_ts)\n",
    "df_disdx = calculate_width_distribution(df_ts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-27T15:26:09.800328Z",
     "start_time": "2020-08-27T15:26:09.686260Z"
    }
   },
   "outputs": [],
   "source": [
    "def all_characteristics_ax(key, ax_ts=None, ax_ra=None, ax_nc=None, ax_dx=None, ax_disdx=None,\n",
    "                          axes_legend_ts=None, axes_legend_ra=None, axes_cbar_nc=None, axes_cbar_disdx=None, show_std=False):\n",
    "    ts = df_ts[key]\n",
    "    ts_mean = df_ts[key].mean()\n",
    "    ts_median = df_ts[key].median()\n",
    "    ts_std = df_ts[key].std()\n",
    "    ts_mean.drop('time', inplace=True)\n",
    "    ts_median.drop('time', inplace=True)\n",
    "    ts_std.drop('time', inplace=True)\n",
    "    ts['time'] -= ts['time'].min()\n",
    "    \n",
    "    ranks = [1, 5, 10, 50, 100]\n",
    "\n",
    "    # Time series.\n",
    "    if ax_ts != None:\n",
    "        PlotTimeseries(ts, ax_ts, raw=True, species_rank=ranks)\n",
    "        \n",
    "        if axes_legend_ts != None:\n",
    "            handles, labels = ax_ts.get_legend_handles_labels()\n",
    "            axes_legend_ts.legend(handles, labels, handlelength=1, fontsize=ELIFE.FONTSIZE)\n",
    "        \n",
    "    # Rank abundance.\n",
    "    if ax_ra != None:\n",
    "        # Plot rank abundance of selected time points.\n",
    "        selected_times = [0, 49, 99, 149]\n",
    "        \n",
    "        for t in selected_times:\n",
    "            abundance_profile = ts[ts['time'] == t].drop('time', axis=1)\n",
    "            PlotRankAbundance(abundance_profile, labels='Day %d' % (int(t)+1), # t + 1 because python counts from 0\n",
    "                              ax=ax_ra, relative=False, raw=True)\n",
    "            #ax_ra.get_legend().remove()\n",
    "        \n",
    "        # Show mean and std of rank abundance curve.\n",
    "        sorted_ts = np.copy(ts.to_numpy()); sorted_ts.sort(axis=1)\n",
    "        sorted_mean, sorted_std = np.mean(sorted_ts, axis=0), np.std(sorted_ts, axis=0)\n",
    "            \n",
    "        ax_ra.fill_between(range(1, len(sorted_mean)+1), (sorted_mean - sorted_std)[::-1],\n",
    "                    (sorted_mean + sorted_std)[::-1], alpha=0.2, color='grey')\n",
    "    \n",
    "        if axes_legend_ra != None:\n",
    "            handles, labels = ax_ra.get_legend_handles_labels()\n",
    "            axes_legend_ra.legend(handles, labels, handlelength=1, fontsize=ELIFE.FONTSIZE)\n",
    "          \n",
    "    # Noise color.\n",
    "    if ax_nc != None:\n",
    "        markers, caps, bars = ax_nc.errorbar(ts_mean, df_ns[key], yerr=df_ns[key + '_std'], \n",
    "                                          xerr = ts_std if show_std else None,\n",
    "                         fmt='o', markersize=1, color='grey')\n",
    "        [bar.set_alpha(0.2 if show_std else 0.4) for bar in bars]\n",
    "        \n",
    "        if axes_cbar_nc != None:\n",
    "            xx = np.linspace(0.9, -3, 500).reshape([500,1])\n",
    "            axes_cbar_nc.imshow(xx, cmap=noise_cmap_ww, vmin=noise_lim[0], vmax=noise_lim[1], \n",
    "                                extent=(0, 1, -3, 0.9),\n",
    "                     aspect='auto', alpha=0.75)\n",
    "\n",
    "            axes_cbar_nc.set_ylabel('Noise color')\n",
    "            axes_cbar_nc.set_xticks([])\n",
    "            axes_cbar_nc.yaxis.set_label_position(\"right\")\n",
    "            axes_cbar_nc.yaxis.tick_right()\n",
    "        \n",
    "    # Absolute value step.\n",
    "    if ax_dx != None:\n",
    "        dx = (ts.values[1:, 1:] - ts.values[:-1, 1:])  # / x.values[:-1, 1:];\n",
    "        dx[~np.isfinite(dx)] = np.nan\n",
    "        mean_dx = np.nanmean(abs(dx), axis=0)\n",
    "        median_dx = np.nanmedian(abs(dx), axis=0)\n",
    "        \n",
    "        x = np.log10(ts_mean[ts_mean != 0])\n",
    "        y = np.log10(mean_dx[ts_mean != 0])\n",
    "        p_lin, cov = np.polyfit(x, y, deg=1, cov=True)\n",
    "\n",
    "        xx = [ts_mean[ts_mean > 0].min(), ts_mean.max()]\n",
    "        ax_dx.plot(xx, 10 ** (p_lin[1] + p_lin[0] * np.log10(xx)), c='k', linewidth=0.5)\n",
    "        ax_dx.annotate(r'y $\\propto$ x$^{%.2f \\pm %.2f} $' % (p_lin[0], np.sqrt(cov[0,0])),(0.3,0.01))\n",
    "        \n",
    "        markers, caps, bars = ax_dx.errorbar(ts_mean, mean_dx, xerr = ts_std if show_std else None,\n",
    "                         fmt='o', markersize=1, color='grey')\n",
    "        [bar.set_alpha(0.2) for bar in bars]\n",
    "\n",
    "    # Width ratios of subsequent points.\n",
    "    if ax_disdx != None:\n",
    "        dx_ratio = df_disdx[key]\n",
    "        \n",
    "        if show_std:\n",
    "            markers, caps, bars = ax_disdx.errorbar(ts_mean, dx_ratio['s'], xerr = ts_std,\n",
    "                         fmt='o', markersize=1, color='grey')\n",
    "            [bar.set_alpha(0.2) for bar in bars]\n",
    "            \n",
    "        sc = ax_disdx.scatter(ts_mean, dx_ratio['s'], c=dx_ratio['ks-pval'], vmin=0, vmax=1, cmap='coolwarm', s=3, zorder=10)\n",
    "        \n",
    "        if axes_cbar_disdx != None:\n",
    "            plt.colorbar(sc, cax=axes_cbar_disdx)\n",
    "            axes_cbar_disdx.set_ylabel('p-value lognormal fit')\n",
    "    return\n",
    "\n",
    "def overview_experimental_data_figure(keys, titles, show_std=False):\n",
    "    fig = plt.figure(figsize=(0.9*ELIFE.FULLWIDTH,7), tight_layout=True)\n",
    "\n",
    "    # Set up all axes\n",
    "\n",
    "    # Define grids for axes.\n",
    "    lm = 0.15 # left margin\n",
    "    rm = 0.85 # right margin\n",
    "\n",
    "    gs_ts = gridspec.GridSpec(2, len(keys), top=0.97, bottom=0.7, left = lm, right=rm, hspace=0.5, wspace=0.1)\n",
    "    gs_ma = gridspec.GridSpec(3, len(keys), top=0.65, bottom=0.22, left = lm, right=rm, hspace=0.05, wspace=0.1)\n",
    "    gs_legend = gridspec.GridSpec(2, 1, top=0.97, bottom=0.7, left = 0.88, right=0.99, hspace=0.5, wspace=0.1)\n",
    "    gs_cbar = gridspec.GridSpec(3, 1, top=0.65, bottom = 0.22, left = 0.88, right=0.9, hspace=0.05, wspace=0.1)\n",
    "\n",
    "    gs_neut = gridspec.GridSpec(2,1,hspace=0, left=lm, right= rm, top=0.15, bottom=0.11) # for neutrality\n",
    "    gs_neut_cbar = gridspec.GridSpec(1,2,wspace=0.2, left=lm, right = rm, top = 0.07, bottom=0.05) # for colorbars neutrality\n",
    "\n",
    "    # Make arrays for all axes.\n",
    "    axes = [[0 for i in range(len(keys))] for j in range(5)]\n",
    "    # Axes of timeseries and rank abundance.\n",
    "    for i in range(2):\n",
    "        for j in range(len(keys)):\n",
    "            if j == 0: # share axes except for timeseries\n",
    "                axes[i][j] = fig.add_subplot(gs_ts[i,j])\n",
    "                if i == 0:\n",
    "                    axes[i][j].set_title(titles[i])\n",
    "            elif i == 0:\n",
    "                axes[i][j] = fig.add_subplot(gs_ts[i,j], sharey=axes[i][0])\n",
    "                axes[i][j].set_title(titles[j])\n",
    "            else:\n",
    "                axes[i][j] = fig.add_subplot(gs_ts[i,j], sharey=axes[i][0], sharex=axes[i][0])\n",
    "            axes[i][j].grid()\n",
    "\n",
    "    # Axes of statistical measures.\n",
    "    for i in range(2,5):\n",
    "        for j in range(len(keys)):\n",
    "            if i-2 == 0 and j == 0: # share axes except for timeseries\n",
    "                axes[i][j] = fig.add_subplot(gs_ma[i-2,j])\n",
    "            elif i-2 == 0:\n",
    "                axes[i][j] = fig.add_subplot(gs_ma[i-2,j], sharey=axes[i][0], sharex=axes[i][0])\n",
    "            elif j == 0:\n",
    "                axes[i][j] = fig.add_subplot(gs_ma[i-2,j], sharex=axes[i-1][j])\n",
    "            else:\n",
    "                axes[i][j] = fig.add_subplot(gs_ma[i-2,j], sharey=axes[i][0], sharex=axes[i-1][j])\n",
    "            axes[i][j].grid()\n",
    "    axes = np.array(axes)\n",
    "    \n",
    "    # Axes colorbars and legends.\n",
    "    axes_cbar_nc = fig.add_subplot(gs_cbar[0], sharey=axes[2][0])\n",
    "    axes_cbar_pval = fig.add_subplot(gs_cbar[-1])\n",
    "    axes_legend_ts = fig.add_subplot(gs_legend[0]); axes_legend_ts.axis('off')\n",
    "    axes_legend_ra = fig.add_subplot(gs_legend[-1]); axes_legend_ra.axis('off')\n",
    "    \n",
    "    # Axes for neutrality measures and their colorbars.\n",
    "    ax_KL = fig.add_subplot(gs_neut[0])\n",
    "    ax_clb_KL = fig.add_subplot(gs_neut_cbar[0])\n",
    "    ax_NCT = fig.add_subplot(gs_neut[1])\n",
    "    ax_clb_NCT = fig.add_subplot(gs_neut_cbar[1])\n",
    "    ax_KL.set_facecolor('lightgrey')\n",
    "    ax_NCT.set_facecolor('lightgrey')\n",
    "    \n",
    "    # Put A-F labels at all rows.\n",
    "    for ax, label in zip(axes[:,0], ('A', 'B', 'C', 'D', 'E')):\n",
    "        ax.text(-0.72, 1.05, label, transform=ax.transAxes,\n",
    "          fontsize=10, fontweight='bold', va='top', ha='right')\n",
    "    ax_KL.text(-0.72*0.23, 1.05, 'F', transform=ax_KL.transAxes,\n",
    "          fontsize=10, fontweight='bold', va='top', ha='right')\n",
    "    \n",
    "    for i, key in enumerate(keys):\n",
    "        ax_ts, ax_ra, ax_nc, ax_dx, ax_disdx = axes[:5, i]\n",
    "        \n",
    "        # Plot all characteristics of one time series.\n",
    "        all_characteristics_ax(key, ax_ts, ax_ra, ax_nc, ax_dx, ax_disdx,\n",
    "                                                      axes_legend_ts, axes_legend_ra, axes_cbar_nc, axes_cbar_pval)\n",
    "\n",
    "        if i == 0:\n",
    "            # Boundaries of axes. Set in log-scale.\n",
    "            vmin = 1e-4; vmax = 1e5\n",
    "\n",
    "            ax_ts.set_ylim([vmin, vmax])\n",
    "            ax_ra.set_ylim([vmin, vmax])\n",
    "            ax_nc.set_ylim([-3,2])\n",
    "            ax_ra.set_xlim([5e-1,3e2])\n",
    "            ax_dx.set_ylim([1e-3, 5e4])\n",
    "            ax_disdx.set_xlim([1e-3, 5e4])\n",
    "            ax_disdx.set_ylim([8e-2, 8e0])\n",
    "\n",
    "            # Log scale.\n",
    "            ax_ts.set_yscale('log')\n",
    "            ax_nc.set_xscale('log')\n",
    "            ax_dx.set_xscale('log')\n",
    "            ax_dx.set_yscale('log')\n",
    "            ax_disdx.set_xscale('log')\n",
    "            ax_disdx.set_yscale('log')\n",
    "\n",
    "            # Hide x tick labels for shared x axes.\n",
    "            for ax in [ax_nc, ax_dx]:\n",
    "                plt.setp(ax_nc.get_xticklabels(), visible=False)\n",
    "\n",
    "            # Labels\n",
    "            ax_ts.set_ylabel('Abundance')\n",
    "            ax_ra.set_ylabel('Abundance')\n",
    "            ax_nc.set_ylabel('Slope power \\n spectral density')\n",
    "            ax_dx.set_ylabel('Difference \\n time points \\n' + r'$\\left< \\mid x(t+\\delta t) - x(t) \\mid \\right>$')\n",
    "                #'Mean absolute \\n difference between successive \\n time points')\n",
    "            ax_disdx.set_ylabel('Width distribution \\n of ratios \\n' + r'$x(t + \\delta t) / x(t)$')\n",
    "\n",
    "            # Add colorbars and legend only once.\n",
    "            axes_legend_ts, axes_legend_ra, axes_cbar_nc, axes_cbar_pval = (None, ) * 4\n",
    "        else:\n",
    "            # Hide y ticks labels for shared axes.\n",
    "            for ax in [ax_ts, ax_ra, ax_nc, ax_dx, ax_disdx]:\n",
    "                plt.setp(ax.get_yticklabels(), visible=False)\n",
    "        \n",
    "        # X-labels and x tick labels.\n",
    "        if i == len(keys) - 1:\n",
    "            ax_ts.set_xlabel('Time (days)', ha='right', x=1)\n",
    "            ax_nc.set_xlabel('Rank', ha='right', x=1)\n",
    "            ax_nc.set_xticks([10,100])\n",
    "            ax_nc.set_xticklabels([10,100])\n",
    "            ax_disdx.set_xlabel('Mean abundance', ha='right', x=1)\n",
    "            ax_disdx.set_xticks([1e-2, 1e1, 1e4])\n",
    "\n",
    "    # Neutrality measures.\n",
    "\n",
    "    neutrality = pd.read_csv('results/experimental/neutrality.csv', index_col=0)\n",
    "    neutrality = neutrality.loc[keys]\n",
    "    \n",
    "    # Plot values of Kullback Leibler divergence.\n",
    "    x = neutrality['KL'].to_numpy(dtype=np.float64)\n",
    "    colors = np.log10(x.reshape([1, len(x)])); colors[np.isinf(colors)] = 3\n",
    "    mat_KL = ax_KL.matshow(colors, origin='lower', cmap='Blues_r', aspect='auto', vmin=-1, vmax=3)\n",
    "    \n",
    "    # Write values of Kullback Leibler divergence.\n",
    "    for i, xx in enumerate(x):\n",
    "        ax_KL.text(i, 0, '{:0.2E}'.format(xx), ha='center', va='center', color='w' if xx < 10 ** (0.5) else 'k')\n",
    "    \n",
    "    # Plot values of neutral covariance test.\n",
    "    x = neutrality['NCT'].to_numpy(dtype=np.float64)\n",
    "    colors = np.log10(x.reshape([1, len(x)]))\n",
    "    vmin = -5; vmax = 0 # pvalue is max 1 = 1e0\n",
    "    norm = PiecewiseNormalize([vmin, np.log10(0.05), vmax], [0, 0.5, 1])\n",
    "    mat_NCT = ax_NCT.matshow(colors, origin='lower', norm=norm, \n",
    "                         cmap='seismic_r', aspect='auto', vmin=vmin, vmax=vmax)\n",
    "    \n",
    "    # Write values of neutral covariance test.\n",
    "    for i, xx in enumerate(x):\n",
    "        ax_NCT.text(i, 0, '{:0.2E}'.format(xx), ha='center', va='center', color='w' if xx < 10 ** (-3) or xx > 10 ** (-0.7) else 'k')\n",
    "    fig.colorbar(mat_NCT, cax=ax_clb_NCT, orientation='horizontal')\n",
    "    \n",
    "    # Put labels for KL divergence and NCT.\n",
    "    ax_KL.set_yticks([0])\n",
    "    ax_KL.set_yticklabels([r'log$_{10}$($D_{KL}$)'])         \n",
    "    ax_NCT.set_yticks([0])\n",
    "    ax_NCT.set_yticklabels([r'log$_{10}$($p_{NCT}$)'])\n",
    "\n",
    "    # Remove ticks of neutrality plots.\n",
    "    ax_NCT.tick_params(axis=\"both\", bottom=False, top=False, labelbottom=False, labeltop=False, left=True, labelleft=True)\n",
    "    ax_KL.tick_params(axis=\"both\", bottom=False, top=False, labelbottom=False, labeltop=False, left=True, labelleft=True)\n",
    "    \n",
    "    # Colorbar for KL divergence and NCT.\n",
    "    fig.colorbar(mat_KL, cax=ax_clb_KL, orientation='horizontal')\n",
    "    ax_clb_KL.set_xlabel(r'log$_{10}$($D_{KL}$)', ha='right', x=1)\n",
    "    \n",
    "    for ax, neutral_tick, niche_tick in zip([ax_clb_KL, ax_clb_NCT], \n",
    "                                             [0.05, 1+(vmax + np.log10(0.05))/(vmax - vmin)/2],\n",
    "                                             [0.95, 1+(vmin + np.log10(0.05))/(vmax - vmin)/2]):\n",
    "        ax_twin = ax.twiny()\n",
    "        ax.xaxis.set_ticks_position('bottom')\n",
    "        ax_twin.xaxis.set_ticks([neutral_tick,niche_tick])\n",
    "        ax_twin.set_xlim([0,1])\n",
    "        ax_twin.xaxis.set_ticklabels(['neutral','niche'])\n",
    "        ax_twin.tick_params(axis='x', direction='out')\n",
    "\n",
    "    fig.align_ylabels(axes[:,0])\n",
    "\n",
    "    return fig\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-27T15:26:14.580581Z",
     "start_time": "2020-08-27T15:26:09.803110Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.7/site-packages/IPython/core/pylabtools.py:132: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "findfont: Font family ['Open Sans'] not found. Falling back to DejaVu Sans.\n",
      "findfont: Font family ['Open Sans'] not found. Falling back to DejaVu Sans.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 471.969x504 with 30 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "keys = ['plankton_eukarya', 'David_stool_A',\n",
    "        'Caporaso_F4_L_palm_L6', 'Caporaso_F4_tongue_L6']\n",
    "\n",
    "titles = ['Plankton eukarya', 'Microbiome stool', \n",
    "          'Microbiome palm', 'Microbiome tongue']\n",
    "\n",
    "overview_experimental_data_figure(keys, titles, show_std=False)\n",
    "#plt.savefig('figures_elife/experimental_summary3.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Figure 2: Noise color"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-28T08:47:37.286933Z",
     "start_time": "2020-08-28T08:47:37.196879Z"
    }
   },
   "outputs": [],
   "source": [
    "def read_file(file, r=None, encoding=1):\n",
    "    if encoding == 1:\n",
    "        x = pd.read_csv(file)\n",
    "        \n",
    "        ss = x['steady state'].astype('float').multiply(r)\n",
    "\n",
    "        x = x[[col for col in x if col.endswith('slope')]]\n",
    "        return ss, np.mean(x.T), np.std(x.T)\n",
    "    elif encoding == 2:\n",
    "        x = pd.read_csv(file, index_col=0)\n",
    "        \n",
    "        ss = x.loc['means'] # steady state\n",
    "        mean_color = x.loc['mean_color']\n",
    "        std_color = x.loc['std_color']\n",
    "        \n",
    "        return ss, mean_color, std_color\n",
    "    return\n",
    " \n",
    "def comparison_ax(files, labels, title, rescale=1, ax=0, mapper=None, encoding=1, raw=False):\n",
    "    if ax == None:\n",
    "        fig = plt.figure(figsize=(4,3.5), tight_layout=True)\n",
    "        ax = fig.add_subplot(111) # 122\n",
    "    \n",
    "    ax.set_xscale('log')\n",
    "    \n",
    "    if isinstance(rescale, (int, float, complex)):\n",
    "        rescale = np.full_like(files, rescale, dtype=float)\n",
    "    elif rescale == None:\n",
    "        rescale = np.full_like(files, 1, dtype=float)\n",
    "        \n",
    "    for i, (f, label, r) in enumerate(zip(files, labels, rescale)):\n",
    "        ss, y, yerr = read_file(f, r=r, encoding=encoding)\n",
    "        \n",
    "        # plot 1 in x points such that plot is not too heavy and the results are alternated \n",
    "        # such that the results for the different labels are visible\n",
    "        skipper = 1 if len(ss) < 100 else len(labels) if len(ss) < 300 else len(labels) + 5\n",
    "           \n",
    "        ax.errorbar(ss[i%skipper::skipper], y[i%skipper::skipper], yerr[i%skipper::skipper], \n",
    "                    linestyle='', marker='.', label=label, markersize=3, \n",
    "                   c = mapper.to_rgba(float(label)) if mapper != None else None)\n",
    "    \n",
    "    if not raw:\n",
    "        ax.set_xlabel(r'Mean abundance $\\times$ self-interaction')\n",
    "        ax.set_ylabel('Slope power spectral density')\n",
    "\n",
    "    # legend from low to high\n",
    "    handles, labels = ax.get_legend_handles_labels()\n",
    "    ax.legend(handles[::-1], labels[::-1], title=title, loc=2, ncol=2 if len(handles)>3 else 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-28T08:51:04.613204Z",
     "start_time": "2020-08-28T08:51:02.988402Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 396.85x288 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def noise_color_implementation_figure():\n",
    "    fig = plt.figure(figsize=(ELIFE.TEXTWIDTH, 4), tight_layout=True)\n",
    "\n",
    "    # Grids for all axes.\n",
    "    yoff = 0.01\n",
    "\n",
    "    gs_top = gridspec.GridSpec(1, 3, top=0.88+yoff, bottom=0.6+yoff,\n",
    "                               left=0.1, right=0.88, wspace=0.05, hspace=0.05)\n",
    "    gs_top_colorbar = gridspec.GridSpec(1, 1, top=0.88+yoff, bottom=0.6+yoff,\n",
    "                                        left=0.9, right=0.92, wspace=0.05, hspace=0.05)\n",
    "\n",
    "    gs_top_comb = gridspec.GridSpec(\n",
    "        1, 1, top=0.95+yoff, bottom=0.55+yoff, left=0.07, right=0.88)\n",
    "\n",
    "    gs_bottom = gridspec.GridSpec(\n",
    "        1, 2, top=0.38+yoff, bottom=0.08+yoff, left=0.1, right=0.88, wspace=0.05, hspace=0.05)\n",
    "    gs_bottom_colorbar = gridspec.GridSpec(1, 1, top=0.38+yoff, bottom=0.08+yoff,\n",
    "                                           left=0.9, right=0.92, wspace=0.05, hspace=0.05)\n",
    "\n",
    "    gs_bottom_comb = gridspec.GridSpec(\n",
    "        1, 1, top=0.45+yoff, bottom=0.03+yoff, left=0.07, right=0.88)\n",
    "\n",
    "    # Labels and titles (with and without interactions)\n",
    "    for title, gs in zip(['Logistic model (without interactions)', 'Generalized Lotka-Volterra model (with interactions)'],\n",
    "                         [gs_top_comb[0], gs_bottom_comb[0]]):\n",
    "        ax = fig.add_subplot(gs, frameon=False)\n",
    "        ax.text(0, 1.08, title, transform=ax.transAxes,\n",
    "                fontsize=9, va='top', ha='left')\n",
    "        ax.set_xlabel(r'Mean abundance $\\times$ self-interaction', ha='right', x=1)\n",
    "        ax.set_ylabel('Slope power \\n spectral density')\n",
    "        ax.set_xticks([])\n",
    "        ax.set_yticks([])\n",
    "\n",
    "    axes = {'A': fig.add_subplot(gs_top[0])}\n",
    "    for i, letter in enumerate(['B', 'C'], start=1):\n",
    "        axes[letter] = fig.add_subplot(\n",
    "            gs_top[i], sharex=axes['A'], sharey=axes['A'])\n",
    "    axes['D'] = fig.add_subplot(gs_bottom[0])\n",
    "    for i, letter in enumerate(['E'], start=1):\n",
    "        axes[letter] = fig.add_subplot(\n",
    "            gs_bottom[i], sharex=axes['D'], sharey=axes['D'])\n",
    "\n",
    "    for letter in ['A', 'B', 'C', 'D', 'E']:\n",
    "        axes[letter].text(0, 1.05, letter, transform=axes[letter].transAxes,\n",
    "                          fontsize=10, fontweight='bold', va='bottom', ha='left')\n",
    "\n",
    "    # Color bars\n",
    "    for gs, share_letter in zip([gs_top_colorbar[0], gs_bottom_colorbar[0]], ['A', 'D']):\n",
    "        ax_cbar = fig.add_subplot(gs, sharey=axes[letter])\n",
    "        noise_colorbar_ax(ax_cbar)\n",
    "\n",
    "    # Logistic equations (without interactions)\n",
    "    path = 'results/without_interactions/'\n",
    "\n",
    "    # implementation\n",
    "    files_noise = [path + 'noise_abundance_Langevin_linear.csv',\n",
    "                   path + 'noise_abundance_Langevin_sqrt.csv',\n",
    "                   path + 'noise_abundance_Langevin_constant.csv'][::-1]\n",
    "\n",
    "    labels = ['Linear multiplicative', 'Sqrt multiplicative', 'Additive'][::-1]\n",
    "\n",
    "    comparison_ax(files_noise, labels, 'Noise implementation', ax=axes['A'], raw=True)\n",
    "    axes['A'].set_xlim([2e-2, 2e2])\n",
    "\n",
    "    # sampling dt\n",
    "\n",
    "    files_noise_samp = [\n",
    "        path + 'noise_abundance_Langevin_samp%d_c.csv' % i for i in range(1, 12)]\n",
    "    labels = ['0.005', '0.01', '0.025', '0.05',\n",
    "              '0.1', '0.25', '1', '2', '2.5', '5', '10']\n",
    "\n",
    "    # make selection\n",
    "    select = [1, 4, 6, 10]\n",
    "    files_noise_samp, labels = np.array(files_noise_samp)[\n",
    "        select], np.array(labels)[select]\n",
    "\n",
    "    comparison_ax(files_noise_samp[::-1], labels[::-1],\n",
    "                  'Sampling $\\delta$t', ax=axes['B'], raw=True)\n",
    "\n",
    "\n",
    "    # noise strength\n",
    "\n",
    "    files_noise_sigma = [\n",
    "        path + 'noise_abundance_Langevin_linear_sigma%d.csv' % d for d in range(1, 6)]\n",
    "\n",
    "    labels = ['0.01', '0.1', '0.2', '0.25', '0.3']\n",
    "\n",
    "    comparison_ax(files_noise_sigma[::-1], labels,\n",
    "                  'Noise strength $\\sigma$', ax=axes['C'], raw=True)\n",
    "\n",
    "    # gLV equations (with interactions)\n",
    "\n",
    "    norm = PiecewiseNormalize([0, 0.21], [0, 1])\n",
    "    mapper = plt.cm.ScalarMappable(norm=norm, cmap='summer')\n",
    "\n",
    "    axes['D'].text(0.1, 1.05, 'Equal abundances', transform=axes['D'].transAxes,\n",
    "                   fontsize=ELIFE.FONTSIZE, va='bottom', ha='left')\n",
    "\n",
    "    path = 'results/with_interactions/'\n",
    "    files_noise_int = [\n",
    "        path + 'noisecolor_Langevin_linear_interaction%d.csv' % d for d in [1, 2, 3, 6]]\n",
    "\n",
    "    labels = ['0.01', '0.05', '0.1', '0.15']\n",
    "\n",
    "    comparison_ax(files_noise_int, labels, r'Interaction strength $\\alpha$',\n",
    "                  mapper=mapper, ax=axes['D'], encoding=2, raw=True)\n",
    "\n",
    "    axes['E'].text(0.1, 1.05, 'Lognormally distributed abundances', transform=axes['E'].transAxes,\n",
    "                   fontsize=ELIFE.FONTSIZE, va='bottom', ha='left')\n",
    "    #ax.set_title('Lognormally distributed abundances')\n",
    "\n",
    "    path = 'results/with_interactions/'\n",
    "    files_noise_pl = [\n",
    "        path + 'noisecolor_Langevin_linear_powerlaw_sigma%d.csv' % d for d in range(1, 5)]\n",
    "\n",
    "    labels = ['0', '0.1', '0.15', '0.2']\n",
    "\n",
    "    comparison_ax(files_noise_pl, labels, r'Interaction strength $\\alpha$',\n",
    "                  mapper=mapper, ax=axes['E'], encoding=2, raw=True)\n",
    "\n",
    "    # Remove tick labels of shared axes\n",
    "    for letter in ['B', 'C', 'E']:\n",
    "        axes[letter].tick_params(axis=\"both\", left=True, labelleft=False)\n",
    "\n",
    "    # Set boundaries y-axis\n",
    "    for letter in ['A', 'D']:\n",
    "        ymin = -3\n",
    "        ymax = 1.5\n",
    "        axes[letter].set_ylim([ymin, ymax])\n",
    "\n",
    "    # Set boundaries x-axis\n",
    "    axes['A'].set_xlim([2e-2, 2e2])\n",
    "    \n",
    "    return fig\n",
    "\n",
    "noise_color_implementation_figure()\n",
    "# plt.savefig('figures_elife/noisecolor_summary4.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Figure 3: Width step distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-27T15:26:16.132748Z",
     "start_time": "2020-08-27T15:26:16.097258Z"
    }
   },
   "outputs": [],
   "source": [
    "#df1 = pd.read_csv('results/width_ratios/width_lognormal_fit_1.csv')\n",
    "#df2 = pd.read_csv('results/width_ratios/width_lognormal_fit_1_interaction0.05.csv')\n",
    "#df3 = pd.read_csv('results/width_ratios/width_lognormal_fit_1_interaction0.1.csv')\n",
    "#df4 = pd.read_csv('results/width_ratios/width_lognormal_fit_1_interaction0.15.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-28T07:55:19.418730Z",
     "start_time": "2020-08-28T07:55:17.423764Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logistic equations (no interactions)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 396.85x165.6 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "gLV equations (with interactions)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 396.85x165.6 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def width_step_figure(with_interactions=False):\n",
    "    mapper = plt.cm.ScalarMappable(\n",
    "        norm=PiecewiseNormalize([0, 0.21], [0, 1]), cmap='summer')\n",
    "\n",
    "    fig = plt.figure(figsize=(ELIFE.TEXTWIDTH, 2.3))\n",
    "\n",
    "    # Grid for axes.\n",
    "    gs_l = gridspec.GridSpec(2, 1, height_ratios=[8, 1], hspace=0.8,\n",
    "                             right=0.25, left=0.1, top=0.9, bottom=0.2)\n",
    "    gs_r = gridspec.GridSpec(2, 2, height_ratios=[1, 3], width_ratios=[10, 1], hspace=0.15, wspace=0.2,\n",
    "                             right=0.9, left=0.4, top=0.9, bottom=0.2)\n",
    "\n",
    "    # Define axes.\n",
    "    ax_mat = fig.add_subplot(gs_l[0])\n",
    "    ax = fig.add_subplot(gs_r[:, 0])\n",
    "\n",
    "    ax_mat_cbar = fig.add_subplot(gs_l[1])\n",
    "    ax_cbar = fig.add_subplot(gs_r[:, 1])\n",
    "\n",
    "    # Label figures (A-B).\n",
    "    ax_mat_tot = fig.add_subplot(gs_l[:])\n",
    "    ax_mat_tot.axis('off')\n",
    "\n",
    "    ax_mat_tot.text(-0.2, 1.1, 'A', transform=ax_mat_tot.transAxes,\n",
    "                    fontsize=10, fontweight='bold', va='top', ha='right')\n",
    "    ax.text(-0.2, 1.1, 'B', transform=ax.transAxes,\n",
    "            fontsize=10, fontweight='bold', va='top', ha='right')\n",
    "\n",
    "    # Matrix\n",
    "    \n",
    "    # TODO check difference between if and else\n",
    "    if not with_interactions:\n",
    "        df_slopes2 = pd.read_csv('results/slopes/slopes_equal_abundances.csv',\n",
    "                                 index_col=0, na_values='NAN')\n",
    "        df_slopes2['slope'] = df_slopes2.iloc[:, 2:12].mean(axis=1)\n",
    "        df_slopes2['slope_std'] = df_slopes2.iloc[:, 2:12].std(axis=1)\n",
    "        df_slopes2.drop(['%d' % i for i in range(10)], axis=1, inplace=True)\n",
    "\n",
    "        slope = df_slopes2.drop(['implementation', 'interaction', 'slope_std'], axis=1)\n",
    "        std_slope = df_slopes2.drop(['implementation', 'interaction', 'slope'], axis=1)\n",
    "\n",
    "        slope = slope.groupby(['noise_lin', 'noise_sqrt']).agg('mean')\n",
    "        std_slope = std_slope.groupby(['noise_lin', 'noise_sqrt']).agg('mean')\n",
    "\n",
    "        slope = slope.unstack()\n",
    "\n",
    "        val = slope.values        \n",
    "    else:\n",
    "        df_slopes = pd.read_csv('results/slopes/interaction_005.csv', index_col=0, na_values='NAN')\n",
    "        df_slopes2 = df_slopes.loc[df_slopes.implementation == 'NOISE.LANGEVIN_LINEAR_SQRT'].copy()\n",
    "        \n",
    "        Nts = 10\n",
    "        \n",
    "        df_slopes2.loc[:,'slope'] = df_slopes2.loc[:,['ts_%d' % i for i in range(Nts)]].mean(axis=1)\n",
    "        df_slopes2.loc[:,'slope_std'] = df_slopes2.loc[:,['ts_%d' % i for i in range(Nts)]].std(axis=1)\n",
    "        df_slopes2.drop(['ts_%d'%i for i in range(Nts)], axis=1, inplace=True)\n",
    "        \n",
    "        slope = df_slopes2.drop(['implementation', 'interaction', 'slope_std', 'noise_ct'], axis=1)\n",
    "        std_slope = df_slopes2.drop(['implementation', 'interaction', 'slope', 'noise_ct'], axis=1)\n",
    "\n",
    "        slope = slope.groupby(['noise_lin', 'noise_sqrt']).agg('mean')\n",
    "        std_slope = std_slope.groupby(['noise_lin', 'noise_sqrt']).agg('mean')\n",
    "\n",
    "        slope = slope.unstack()\n",
    "        std_slope = std_slope.unstack().iloc[:4, :4]\n",
    "\n",
    "        val = slope.values\n",
    "        val[0][0] = np.nan\n",
    "    \n",
    "    mat = ax_mat.matshow(val, cmap='coolwarm', vmin=0.65, vmax=1.1)\n",
    "    ax_mat.set_xlabel(r'$\\sigma_\\mathregular{sqrt}$')\n",
    "    ax_mat.set_ylabel(r'$\\sigma_\\mathregular{lin}$')\n",
    "        \n",
    "    # Ticks\n",
    "    ax_mat.set_xticks([0, 1, 2, 3, 4])\n",
    "    ax_mat.set_yticks([0, 1, 2, 3, 4])\n",
    "    ax_mat.set_xticklabels([0, 0.01, 0.1, 0.5, 1.0], rotation=90)\n",
    "    ax_mat.set_yticklabels([0, 0.01, 0.1, 0.5, 1.0])\n",
    "    ax_mat.tick_params(axis='both', top=False, bottom=True,\n",
    "                       labelbottom=True, labeltop=False)\n",
    "\n",
    "    # colorbar\n",
    "    cbar = plt.colorbar(mat, cax=ax_mat_cbar, orientation='horizontal')\n",
    "    cbar.set_label(r'Slope $\\left< \\mid x(t+\\delta t) - x(t) \\mid \\right>$')\n",
    "\n",
    "    # Right plot\n",
    "    sigmas = [0.01, 0.1, 1.0]\n",
    "\n",
    "    dfs = []\n",
    "    \n",
    "    if with_interactions:\n",
    "        df = pd.read_csv('results/width_ratios/width_lognormal_fit_experimental.csv')\n",
    "        m = 'o' # marker\n",
    "    else:\n",
    "        df = pd.read_csv('results/width_ratios/width_lognormal_fit_experimental_interaction.csv')\n",
    "        m = '^' # marker\n",
    "\n",
    "    for j, sigma in enumerate(sigmas):\n",
    "        # Get width, p-value, steady state and selfinteraction.\n",
    "        w = df[['sigma_%.2f_width_mean_%d' %\n",
    "                (sigma, d) for d in range(20)]].median(axis=1).values\n",
    "        pval = df[['sigma_%.2f_pval_%d' %\n",
    "                   (sigma, d) for d in range(20)]].median(axis=1).values\n",
    "        ss = df['ss'].values\n",
    "        si = df['selfints'].values\n",
    "        \n",
    "        # Define x = steady state * selfinteraction\n",
    "        x = ss * si\n",
    "\n",
    "        # Sort values.\n",
    "        p = x.argsort()\n",
    "\n",
    "        x = x[p]\n",
    "        w = w[p]\n",
    "        pval = pval[p]\n",
    "        ss = ss[p]\n",
    "        si = si[p]\n",
    "        \n",
    "        # Plot widths\n",
    "        #col = mapper.to_rgba(alpha) # color\n",
    "        ax.plot(x, w, c='lightgrey', alpha=0.3)\n",
    "        \n",
    "        s_ax = ax.scatter(x, w, s=3, c=pval, cmap='coolwarm',\n",
    "                          vmin=0, vmax=1, marker=m)\n",
    "        \n",
    "        xl = 1e0; yl = w[0] # position label\n",
    "        ax.annotate(r\"$\\sigma_\\mathregular{lin} =$ %.2f\" % sigma, xy=(\n",
    "                xl, yl), xytext=(xl, 1.5*yl), ha='left')\n",
    "    \n",
    "    # orientation='horizontal')\n",
    "    cbar = plt.colorbar(s_ax, cax=ax_cbar, orientation='vertical')\n",
    "    cbar.set_label('p-value lognormal fit')\n",
    "\n",
    "    # Labels\n",
    "    ax.set_xlabel(r'Mean abundance $\\times$ self-interaction', ha='right', x=1)\n",
    "    ax.set_ylabel('Width distribution \\n of ratios ' + r'$x(t + \\delta t) / x(t)$')\n",
    "\n",
    "    # Boundaries axes\n",
    "    ax.set_xlim([5e-1, 5e1])\n",
    "    ax.set_ylim([9e-4, 2e0])\n",
    "\n",
    "    # Scale axes\n",
    "    ax.set_xscale('log')\n",
    "    ax.set_yscale('log')\n",
    "\n",
    "    ax.grid()\n",
    "    \n",
    "    return fig\n",
    "\n",
    "print(\"Logistic equations (no interactions)\")\n",
    "width_step_figure()\n",
    "# plt.savefig('figures_elife/interaction_lognormal_fit2.pdf')\n",
    "plt.show()\n",
    "\n",
    "print(\"gLV equations (with interactions)\")\n",
    "width_step_figure(with_interactions=True)\n",
    "# plt.savefig('figures_elife/interaction_lognormal_fit2.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Figure 4: Example time series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-28T08:24:11.271744Z",
     "start_time": "2020-08-28T08:24:11.232498Z"
    }
   },
   "outputs": [],
   "source": [
    "def experimental_abundance_noise_color():\n",
    "    x = df_ts['David_stool_A']\n",
    "    \n",
    "    # Do not consider the traveling\n",
    "    x = x.loc[150:].copy()\n",
    "    \n",
    "    x.drop('time', axis=1, inplace=True)\n",
    "    \n",
    "    experimental_abundance = np.sort(x.values[0,:])[::-1]\n",
    "    experimental_noise_color = noise_color(x.values.T)\n",
    "    \n",
    "    return experimental_abundance, experimental_noise_color\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-28T08:24:11.707042Z",
     "start_time": "2020-08-28T08:24:11.606591Z"
    }
   },
   "outputs": [],
   "source": [
    "def plot_timeseries_comparison(files, titles=[], ffig=None, mean_slope=False,\n",
    "                               composition=['ts', 'psd', 'nc', 'dx', 'disdx', 'ra', 'nn'], \n",
    "                               vertical=True, fig=0, show_std = False):\n",
    "    if fig != 0 and isinstance(fig, matplotlib.axes.Axes) and len(composition) > 1 and len(files) > 1:\n",
    "        raise ValueError(\"fig / ax / multiple compositions / multiple files\")\n",
    "\n",
    "    if fig == 0:\n",
    "        if vertical == True:\n",
    "            fig = plt.figure(figsize=(3 * len(files), 2.5 * len(composition))) #, tight_layout=True)\n",
    "            gs = gridspec.GridSpec(len(composition), len(files), top=0.9, bottom=0.2, wspace=0.5, left=0.1, right=0.9)\n",
    "        else:\n",
    "            fig = plt.figure(figsize=(3 * len(composition), 2.5 * len(files))) #, tight_layout=True)\n",
    "            gs = gridspec.GridSpec(len(files), len(composition), top=0.9, bottom=0.2, wspace=0.5,\n",
    "                                   width_ratios=[2 if ci == 'nn' else 3 for ci in composition], left=0.1, right=0.9)\n",
    "\n",
    "    for i, f in enumerate(files):\n",
    "        if isinstance(f, str):\n",
    "            x = pd.read_csv(f, na_values='NAN')\n",
    "        elif isinstance(f, pd.DataFrame):\n",
    "            x = f.copy()\n",
    "\n",
    "        mean = x.mean()\n",
    "        mean.drop('time', inplace=True)\n",
    "        std = x.std()\n",
    "        std.drop('time', inplace=True)\n",
    "        \n",
    "        vmin = 0.1 * np.nanmin(mean.values[mean.values != np.inf])\n",
    "        vmax = 10 * np.nanmax(mean.values[mean.values != np.inf])\n",
    "\n",
    "        # make all axes\n",
    "\n",
    "        if i == 0:\n",
    "            if fig != 0 and isinstance(fig, matplotlib.axes.Axes) and len(composition) == 1:\n",
    "                globals()['ax_' + composition[0]] = fig\n",
    "            elif fig != 0 and composition == ['nn'] and len(fig) == 2:\n",
    "                globals()['ax_KL'] = fig[0]\n",
    "                globals()['ax_NCT'] = fig[1]\n",
    "            else:\n",
    "                for c in composition:\n",
    "                    if vertical == True:\n",
    "                        row = composition.index(c)\n",
    "                        col = i\n",
    "                    else:\n",
    "                        col = composition.index(c)\n",
    "                        row = i\n",
    "\n",
    "                    if c == 'nn':\n",
    "                        sub_gs = gs[row, col].subgridspec(4, 1, height_ratios=[2, 1, 1, 2])\n",
    "                        globals()['ax_KL'] = fig.add_subplot(sub_gs[1])\n",
    "                        globals()['ax_NCT'] = fig.add_subplot(sub_gs[2])\n",
    "                    else:\n",
    "                        globals()['ax_' + c] = fig.add_subplot(gs[row, col])\n",
    "\n",
    "            if 'ts' in composition:\n",
    "                ax_ts.set_ylabel('Abundance')\n",
    "\n",
    "            if 'nc' in composition:\n",
    "                ax_nc.set_ylabel('Slope power \\n spectral density')\n",
    "\n",
    "            if 'dx' in composition:\n",
    "                ax_dx.set_ylabel('Mean absolute \\n step')\n",
    "\n",
    "            if 'ra' in composition:\n",
    "                ax_ra.set_ylabel('Abundance')\n",
    "        else:\n",
    "            for c in composition:\n",
    "                if vertical == True:\n",
    "                    row = composition.index(c)\n",
    "                    col = i\n",
    "                else:\n",
    "                    col = composition.index(c)\n",
    "                    row = i\n",
    "\n",
    "                if c == 'nn':\n",
    "                    sub_gs = gs[row, col].subgridspec(4, 1, height_ratios=[2, 1, 1, 2])\n",
    "                    globals()['ax_KL'] = fig.add_subplot(sub_gs[1])\n",
    "                    globals()['ax_NCT'] = fig.add_subplot(sub_gs[2])\n",
    "                else:\n",
    "                    globals()['ax_' + c] = fig.add_subplot(gs[row, col])\n",
    "\n",
    "        # set title\n",
    "        if len(titles) == len(files):\n",
    "            globals()['ax_' + composition[0]].set_title(titles[i])\n",
    "\n",
    "        skip = max(1, int(len(x) / 500))\n",
    "\n",
    "        N = len(x.columns) - 1\n",
    "\n",
    "        if 'ts' in composition or 'psd' in composition:\n",
    "            # plot different mean abundances, first sort the species\n",
    "            sorted_species = mean.sort_values().index.tolist()[::-1]\n",
    "\n",
    "            skip = max(1, int(len(x) / 500))\n",
    "            for species in sorted_species[::max(1, int(N / 4))]:\n",
    "                if 'ts' in composition:\n",
    "                    ax_ts.plot(x['time'][::skip], x[species][::skip])\n",
    "\n",
    "                if 'psd' in composition:\n",
    "                    example_noise_fit(ax_psd, x[species])\n",
    "\n",
    "                    if i > 0:\n",
    "                        ax_psd.set_ylabel('')\n",
    "\n",
    "            if 'ts' in composition:\n",
    "                ax_ts.set_xlabel('Time', ha='right', x=1)\n",
    "                ax_ts.set_yscale('log')\n",
    "\n",
    "        if ('psd' in composition and mean_slope) or 'nc' in composition:\n",
    "            nc = noise_color(x)\n",
    "            ns = nc['slope_linear']\n",
    "\n",
    "            if 'psd' in composition:\n",
    "                ax_psd.legend([], [], title='mean slope = %.2f + %.2f' % (np.mean(ns), np.std(ns)))\n",
    "\n",
    "            if 'nc' in composition:\n",
    "                markers, caps, bars = ax_nc.errorbar(mean, ns, yerr=nc['std_slope_linear'], xerr = std if show_std else None,\n",
    "                         fmt='o', markersize=1, color='grey')\n",
    "                [bar.set_alpha(0.2 if show_std else 0.4) for bar in bars]\n",
    "        \n",
    "                ax_nc.set_xscale('log')\n",
    "                ax_nc.set_xlabel('Mean abundance', ha='right', x=1)\n",
    "\n",
    "        if 'dx' in composition:\n",
    "            dx = (x.values[1:, 1:] - x.values[:-1, 1:])  # / x.values[:-1, 1:];\n",
    "            dx[~np.isfinite(dx)] = np.nan\n",
    "            mean_dx = np.nanmean(abs(dx), axis=0)\n",
    "\n",
    "            p_lin, cov = np.polyfit(np.log10(mean[~np.isnan(mean_dx)]), np.log10(mean_dx[~np.isnan(mean_dx)]), deg=1,\n",
    "                               cov=True)\n",
    "\n",
    "            xx = [np.nanmin(mean.values), np.nanmax(mean.values)]\n",
    "            ax_dx.plot(xx, 10 ** (p_lin[1] + p_lin[0] * np.log10(xx)), c='k', linewidth=0.5)\n",
    "                      # label= 'y $\\propto$ x$^{%.2f}$' % p_lin[0])\n",
    "            ax_dx.text(0.95, 0.05, r'y $\\propto$ x$^{%.2f \\pm %.2f}$' % (p_lin[0], np.sqrt(cov[0,0])), \n",
    "                       transform=ax_dx.transAxes, va='bottom', ha='right')\n",
    "            \n",
    "            markers, caps, bars = ax_dx.errorbar(mean, mean_dx, yerr=None, xerr = std if show_std else None,\n",
    "                         fmt='o', markersize=1, color='grey')\n",
    "            [bar.set_alpha(0.2 if show_std else 0.4) for bar in bars]\n",
    "        \n",
    "            if np.log10(max(mean[mean > 0])) - np.log10(min(mean[mean > 0])) > 1:\n",
    "                ax_dx.set_xscale('log')\n",
    "            if np.log10(max(mean_dx[mean_dx > 0])) - np.log10(min(mean_dx[mean_dx > 0])) > 1:\n",
    "                ax_dx.set_yscale('log')\n",
    "            ax_dx.set_xlabel('Mean abundance', ha='right', x=1)\n",
    "            ax_dx.legend(loc=4, frameon=False)\n",
    "            #ax_dx.grid()\n",
    "\n",
    "        if 'disdx' in composition:\n",
    "            def fit_ratio(x):\n",
    "                x = x[:-1] / x[1:]\n",
    "                x = x[np.isfinite(x)]\n",
    "\n",
    "                if len(x) > 5:\n",
    "                    a, b, c = stats.lognorm.fit(x, floc=0)  # Gives the paramters of the fit\n",
    "                    stat, pval = stats.kstest(x, 'lognorm', args=((a, b, c)))\n",
    "\n",
    "                    return a, b, c, stat, pval\n",
    "                else:\n",
    "                    return (np.nan, np.nan, np.nan, np.nan, np.nan)\n",
    "\n",
    "            dx_ratio = pd.DataFrame(index=x.columns, columns=['s', 'loc', 'scale', 'ks-stat', 'ks-pval'])\n",
    "            dx_ratio.drop('time', inplace=True)\n",
    "\n",
    "            for idx in dx_ratio.index:\n",
    "                dx_ratio.loc[idx] = fit_ratio(x[idx].values)  # b = 0, c = 1\n",
    "\n",
    "            ax_disdx.scatter(mean, dx_ratio['s'], c=dx_ratio['ks-pval'], vmin=0, vmax=1, cmap='coolwarm', s=3, zorder=10)\n",
    "            markers, caps, bars = ax_disdx.errorbar(mean, dx_ratio['s'], yerr=None, xerr = std if show_std else None,\n",
    "                         fmt='o', markersize=1, color='grey')\n",
    "            [bar.set_alpha(0.2 if show_std else 0.4) for bar in bars]\n",
    "            \n",
    "            ax_disdx.set_xscale('log')\n",
    "            ax_disdx.set_yscale('log')\n",
    "            ax_disdx.set_ylabel('Width step\\n distribution')\n",
    "            ax_disdx.set_xlabel('Mean abundance', ha='right', x=1)\n",
    "\n",
    "            ax_disdx.set_xlim([vmin, vmax])\n",
    "            ax_disdx.set_ylim([1e-3, 1e2])\n",
    "\n",
    "        if 'ra' in composition:\n",
    "            selected_times = [0, 50, 100, 150] #x['time'][::int(len(x['time']) / 3)]\n",
    "\n",
    "            for t in selected_times:\n",
    "                abundance_profile = x[x['time'] == t].values.flatten()[1:]\n",
    "                ax_ra.plot(range(1, len(abundance_profile) + 1), np.sort(abundance_profile)[::-1],\n",
    "                           label='Day %d' % int(t))\n",
    "            \n",
    "            sorted_ts = np.copy(ts.to_numpy()); sorted_ts.sort(axis=1)\n",
    "            sorted_mean, sorted_std = np.mean(sorted_ts, axis=0), np.std(sorted_ts, axis=0)\n",
    "            \n",
    "            ax.fill_between(range(1, len(sorted_mean)+1), (sorted_mean - sorted_std)[::-1],\n",
    "                    (sorted_mean + sorted_std)[::-1], alpha=0.2, color='grey')\n",
    "        \n",
    "            ax_ra.set_xlabel('Rank', ha='right', x=1)\n",
    "            ax_ra.set_xscale('log')\n",
    "            ax_ra.set_yscale('log')\n",
    "            ylim = ax_ra.get_ylim()\n",
    "            ax_ra.set_ylim([max(1e-5, ylim[0]), ylim[1]])\n",
    "            ax_ra.legend(ncol=2, columnspacing=0.5)\n",
    "\n",
    "        if 'nn' in composition:\n",
    "            KL = KullbackLeibler_neutrality(x, verbose=False)\n",
    "            norm_ts = x.values[:, 1:].copy()\n",
    "            norm_ts /= norm_ts.sum(axis=1, keepdims=True)\n",
    "            NCT = neutral_covariance_test(norm_ts, ntests=500, method='Kolmogorov', seed=56)\n",
    "            print('NCT', NCT)\n",
    "            \n",
    "            ax_KL.matshow([[np.log10(KL)]], cmap='Blues_r', vmin=-1, vmax=3, aspect='auto', )\n",
    "            ax_KL.set_xticks([])\n",
    "            ax_KL.set_yticks([0])\n",
    "            ax_KL.set_yticklabels([r'$D_{KL}$'], fontsize=ELIFE.FONTSIZE)\n",
    "            ax_KL.tick_params(axis=\"both\", left=False, labelleft=True)\n",
    "            ax_KL.text(0, 0, '{:0.2E}'.format(KL), ha='center', va='center', color='w' if KL < 10 ** (0.5) else 'k')\n",
    "            \n",
    "            norm = PiecewiseNormalize([-5, np.log10(0.05), 0], [0, 0.5, 1])\n",
    "            ax_NCT.matshow([[np.log10(NCT)]], norm=norm, cmap='seismic_r', aspect='auto', vmin=-5, vmax=0)\n",
    "            ax_NCT.set_xticks([])\n",
    "            ax_NCT.set_yticks([0])\n",
    "            ax_NCT.set_yticklabels([r'$p_{NCT}$'], fontsize=ELIFE.FONTSIZE)\n",
    "            ax_NCT.tick_params(axis=\"both\", left=False, labelleft=True)\n",
    "            ax_NCT.text(0, 0, '{:0.2E}'.format(NCT), ha='center', va='center',\n",
    "                        color='w' if NCT < 10 ** (-3) or NCT > 10 ** (-0.7) else 'k')\n",
    "\n",
    "\n",
    "        if len(titles) == len(files) and not np.any(np.isnan(x.values)):\n",
    "            print(titles[i], KullbackLeibler_neutrality(x))\n",
    "\n",
    "    # limit visible yrange of timeseries (do not show values that go to values close to zero/infinity)\n",
    "    if 'ts' in composition:\n",
    "        ylim1, ylim2 = ax_ts.get_ylim()\n",
    "        ylim1 = max(1e-5, ylim1)\n",
    "        ylim2 = min(1e6, ylim2)\n",
    "        ax_ts.set_ylim([ylim1, ylim2])\n",
    "\n",
    "    if ffig != None:\n",
    "        plt.savefig(ffig)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-28T08:24:11.996975Z",
     "start_time": "2020-08-28T08:24:11.946095Z"
    }
   },
   "outputs": [],
   "source": [
    "N = 80\n",
    "\n",
    "def mimic_experimental(with_interactions=False):\n",
    "    experimental_abundance, experimental_noise_color = experimental_abundance_noise_color()\n",
    "    \n",
    "    def find_ss_selfint(x):\n",
    "        amplitude = 2.10E+00 \n",
    "        x0 = 2.87E+00\n",
    "        k = 1.14E+00\n",
    "        offset = -1.77E+00\n",
    "\n",
    "        return 10**( -1/x0 * np.log(amplitude/(x-offset) - 1) + k)\n",
    "\n",
    "    params = {}\n",
    "\n",
    "    steadystate = (experimental_abundance[:N]).reshape([N, 1]) # * 10\n",
    "\n",
    "    selfints = -find_ss_selfint(experimental_noise_color['slope_linear'].values[:N]) / steadystate.flatten()\n",
    "\n",
    "    # no interaction\n",
    "    if not with_interactions:\n",
    "        omega = np.zeros([N,N]); np.fill_diagonal(omega, selfints) #np.random.uniform(-1, 0, N)) # np.random.normal(0,0.02,[N, N]);\n",
    "    else:\n",
    "        omega = np.random.normal(0, 0.02, [N, N]);\n",
    "        omega *= np.random.choice([0, 1], [N, N], p=[0.9, 0.1]);\n",
    "        np.fill_diagonal(omega, selfints)\n",
    "    \n",
    "    params['interaction_matrix'] = omega\n",
    "\n",
    "    # no immigration\n",
    "    params['immigration_rate'] = np.zeros([N, 1])\n",
    "\n",
    "    # different growthrates determined by the steady state\n",
    "    params['growth_rate'] = - (omega).dot(steadystate)\n",
    "\n",
    "    params['initial_condition'] = np.copy(steadystate) * np.random.normal(1,0.1,steadystate.shape)\n",
    "\n",
    "    params['noise_linear'] = 2.5\n",
    "\n",
    "    ts = Timeseries(params, noise_implementation = NOISE.LANGEVIN_LINEAR, \n",
    "                        dt = 0.01, tskip=49, T=50.0, seed=int(time.time())).timeseries\n",
    "    ts.time = np.arange(1, len(ts)+1)\n",
    "    \n",
    "    return ts\n",
    "\n",
    "KL = np.zeros(100)\n",
    "NCT = np.zeros(100)\n",
    "\n",
    "def check_neutrality_100_timeseries():\n",
    "    for i in range(100):\n",
    "        print(i)\n",
    "        ts = mimic_experimental()\n",
    "        KL[i] = KullbackLeibler_neutrality(ts)\n",
    "        norm_ts = ts.values[:, 1:].copy()\n",
    "        norm_ts /= norm_ts.sum(axis=1, keepdims=True)\n",
    "        NCT[i] = neutral_covariance_test(norm_ts, ntests=500, method='Kolmogorov', seed=56)\n",
    "\n",
    "    print(\"KL\", KL)\n",
    "    print(\"NCT\", NCT)\n",
    "\n",
    "# check_neutrality_100_timeseries()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-28T08:26:18.750101Z",
     "start_time": "2020-08-28T08:26:18.688404Z"
    }
   },
   "outputs": [],
   "source": [
    "def example_figure(show_std=False, with_interactions=False, normalized=False):\n",
    "    ts = mimic_experimental(with_interactions)\n",
    "    \n",
    "    if normalized:\n",
    "        ts = ts.div(ts.loc[:,'species_1':].sum(axis=1), axis=0)*np.mean(ts.loc[:,'species_1':].sum(axis=1))\n",
    "        ts['time'] = np.arange(1,101)\n",
    "        ts = ts[['time'] + ['species_%d' % d for d in range(1,N+1)]]\n",
    "    ranks = [1, 5, 10, 50]\n",
    "    \n",
    "    fig = plt.figure(figsize=(ELIFE.TEXTWIDTH,3)) #, tight_layout=True)\n",
    "\n",
    "    gs1a = gridspec.GridSpec(1,2, wspace=0.1, hspace=0.3, left=0.12, right=0.57, top=0.9, bottom=0.62)\n",
    "    gs1b = gridspec.GridSpec(1,2, wspace=0.1, width_ratios=[9,1], hspace=0.3, left=0.7, right=0.93, top=0.9, bottom=0.62)\n",
    "    gs2a = gridspec.GridSpec(1,2, wspace=0.7, hspace=0.4, left=0.12, right=0.7, top=0.4, bottom=0.12)\n",
    "    gs2b = gridspec.GridSpec(1,1, wspace=0.7, hspace=0.4, left=0.8, right=0.92, top=0.4, bottom=0.12)\n",
    "    \n",
    "    gs_tot = gridspec.GridSpec(1, 1, left=0.12, right=0.95, bottom=0.12, top=0.95)\n",
    "    \n",
    "    ax = fig.add_subplot(gs_tot[0], frameon=False)\n",
    "    ax.axis('off')\n",
    "    for letter, x, y in zip(['A', 'B', 'C', 'D', 'E', 'F'],\n",
    "                            [-0.1, 0.3, 0.6, -0.1, 0.3, 0.75], \n",
    "                            [1.03, 1.03, 1.03, 0.43, 0.43, 0.43]):\n",
    "        ax.text(x, y, letter, transform=ax.transAxes, fontsize=10, \n",
    "                fontweight='bold', va='top', ha='right')\n",
    "    \n",
    "    # timeseries\n",
    "    ax = fig.add_subplot(gs1a[0])\n",
    "    ax.grid()\n",
    "    \n",
    "    PlotTimeseries(ts, ax, species_rank=ranks) # raw=True, \n",
    "    ax.set_ylabel('Abundance')\n",
    "    ax.set_xlabel('Time (days)', x=1, ha='right')\n",
    "    ax.set_ylim([1e0, 1e5])\n",
    "    \n",
    "    ax = fig.add_subplot(gs1a[1], sharey=ax)\n",
    "    ax.grid()\n",
    "    selected_times = [1, 50, 100, 150]\n",
    "    for t in selected_times:\n",
    "        abundance_profile = ts[ts['time'] == t].drop('time', axis=1)\n",
    "        PlotRankAbundance(abundance_profile, labels='Day %d' % int(t), ax=ax, relative=False, raw=True)\n",
    "        ax.legend(ncol=2, columnspacing=0.5)\n",
    "    sorted_ts = np.copy(ts.to_numpy()); sorted_ts.sort(axis=1)\n",
    "    sorted_mean, sorted_std = np.mean(sorted_ts, axis=0), np.std(sorted_ts, axis=0)\n",
    "            \n",
    "    ax.fill_between(range(1, len(sorted_mean)+1), (sorted_mean - sorted_std)[::-1],\n",
    "                (sorted_mean + sorted_std)[::-1], alpha=0.2, color='grey')\n",
    "\n",
    "    ax.set_xlabel('Rank', x=1, ha='right')\n",
    "    ax.tick_params(labelleft=False) \n",
    "    \n",
    "    ax = fig.add_subplot(gs2b[-1], frameon=False)\n",
    "    ax.tick_params(left=False, labelleft=False, bottom=False, labelbottom=False)\n",
    "\n",
    "    sub_gs = gs2b[0].subgridspec(4, 1, height_ratios=[1.5, 1, 1, 1.5], hspace=0.3)\n",
    "    ax_KL = fig.add_subplot(sub_gs[1])\n",
    "    ax_NCT = fig.add_subplot(sub_gs[2])\n",
    "    plot_timeseries_comparison([ts], composition=['nn'], fig=[ax_KL, ax_NCT], show_std=show_std) #, ffig = 'figures/interaction_rescaled_model.png')\n",
    "\n",
    "    # characteristics\n",
    "\n",
    "    for gsi, char in zip([gs1b[0], gs2a[0], gs2a[1]], ['nc', 'dx', 'disdx']):\n",
    "        ax = fig.add_subplot(gsi)\n",
    "\n",
    "        ax.grid()\n",
    "        plot_timeseries_comparison([ts], composition=[char], fig=ax, show_std=show_std) #, ffig = 'figures/interaction_rescaled_model.png')\n",
    "        if char == 'disdx':\n",
    "            ax.set_ylim([1e-2,1e2])\n",
    "            ax.set_ylabel('Width distribution \\n of ratios \\n' + r'$x(t + \\delta t) / x(t)$')\n",
    "        elif char == 'dx':\n",
    "            ax.set_ylabel('Difference \\n time points \\n' + r'$\\left< \\mid x(t+\\delta t) - x(t) \\mid \\right>$')\n",
    "        elif char == 'nc':\n",
    "            ax.set_ylim([-3,1])\n",
    "            ax = fig.add_subplot(gs1b[1], sharey=ax)\n",
    "            noise_colorbar_ax(ax)\n",
    "    \n",
    "    return fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-28T08:26:30.355996Z",
     "start_time": "2020-08-28T08:26:19.038830Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NCT 4.578350054938742e-07\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No handles with labels found to put in legend.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 396.85x216 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_std=False\n",
    "with_interactions=False\n",
    "normalized=False\n",
    "\n",
    "figfile = 'figures_elife/supplemental/logistic_model'\n",
    "if with_interactions:\n",
    "    figfile += '_interactions'\n",
    "if normalized:\n",
    "    figfile += '_normalized'\n",
    "if show_std:\n",
    "    figfile += '_std'\n",
    "figfile += '.pdf'\n",
    "\n",
    "with warnings.catch_warnings():\n",
    "    warnings.simplefilter(\"ignore\", RuntimeWarning)\n",
    "    \n",
    "    example_figure(show_std, with_interactions, normalized)\n",
    "    #plt.savefig(figfile)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.7.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}