gg230221_modelfit.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8ca96414",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from numpy import matlib\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff2a970c",
   "metadata": {},
   "source": [
    "## Convenience functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec173c9d",
   "metadata": {},
   "source": [
    "### Parallelization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "fff14152",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def parallelize(\n",
    "    function,\n",
    "    iterable,\n",
    "    num_cores,\n",
    "    num_entries,\n",
    "    completion_message=\"Parallelization complete.\",\n",
    "    termination_message=\"Parallelization manually terminated.\",\n",
    "    error_message=\"Parallelization terminated due to error.\",\n",
    "    use_tqdm=True,\n",
    "):\n",
    "    try:\n",
    "        pool = multiprocessing.Pool(processes=num_cores)\n",
    "        if use_tqdm:\n",
    "            x = list(tqdm(pool.imap(function, iterable), total=num_entries))  # hacky\n",
    "        else:\n",
    "            x = pool.map(function, iterable)\n",
    "        pool.close()\n",
    "        pool.join()\n",
    "        log.info(completion_message)\n",
    "    except KeyboardInterrupt:\n",
    "        log.warning(termination_message)\n",
    "        pool.terminate()\n",
    "        pool.join()\n",
    "    except ValueError:\n",
    "        log.warning(error_message)\n",
    "        pool.terminate()\n",
    "        pool.join()\n",
    "    return x\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97750084",
   "metadata": {},
   "source": [
    "### Reduced parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b29ea907",
   "metadata": {},
   "outputs": [],
   "source": [
    "def encode_xy_tele_1d(kon,koff,kinit,beta):\n",
    "    kappa = kon+koff\n",
    "    K_avg = kon*kinit/kappa\n",
    "    x = kappa/(kappa+beta)\n",
    "    a = kon*kappa/koff\n",
    "    theta = koff*kinit/kappa\n",
    "    y = theta/(theta+a)\n",
    "    return x,y,K_avg,beta\n",
    "\n",
    "def encode_xy_sde_1d(a,kappa,theta,beta):\n",
    "    K_avg = a*theta/kappa\n",
    "    x = kappa/(kappa+beta)\n",
    "    y = theta/(theta+a)\n",
    "    return x,y,K_avg,beta\n",
    "\n",
    "def decode_xy_tele_1d(x, y, K_avg, beta):\n",
    "    kappa = (beta)*(x/(1-x))\n",
    "    ath = 1/y - 1\n",
    "    c = K_avg*ath/kappa\n",
    "    kon = np.sqrt(c) * kappa/ (np.sqrt(c) + 1)\n",
    "    koff = kappa / (np.sqrt(c) + 1)\n",
    "    kinit = K_avg * kappa / kon\n",
    "    return kon,koff,kinit, beta\n",
    "def decode_xy_sde_1d(x, y, K_avg, beta):\n",
    "    kappa = (beta)*(x/(1-x))\n",
    "    a_over_th = 1/y - 1\n",
    "    theta = np.sqrt(kappa*K_avg/a_over_th)\n",
    "    a = K_avg*kappa/theta\n",
    "    return a, kappa, theta, beta\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "61432e2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def encode_xy_tele_2d(kon,koff,kinit,beta,gamma):\n",
    "    kappa = kon+koff\n",
    "    K_avg = kon*kinit/kappa\n",
    "    x = kappa/(kappa+beta+gamma)\n",
    "    a = kon*kappa/koff\n",
    "    theta = koff*kinit/kappa\n",
    "    y = theta/(theta+a)\n",
    "    return x,y,K_avg,beta,gamma\n",
    "\n",
    "def encode_xy_sde_2d(a,kappa,theta,beta,gamma):\n",
    "    K_avg = a*theta/kappa\n",
    "    x = kappa/(kappa+beta+gamma)\n",
    "    y = theta/(theta+a)\n",
    "    return x,y,K_avg,beta,gamma\n",
    "\n",
    "def decode_xy_tele_2d(x,y,K_avg,beta,gamma):\n",
    "    kappa = (beta+gamma)*(x/(1-x))\n",
    "    ath = 1/y - 1\n",
    "    c = K_avg*ath/kappa\n",
    "    kon = np.sqrt(c) * kappa/ (np.sqrt(c) + 1)\n",
    "    koff = kappa / (np.sqrt(c) + 1)\n",
    "    kinit = K_avg * kappa / kon\n",
    "    return kon,koff,kinit,beta,gamma\n",
    "\n",
    "def decode_xy_sde_2d(x, y, K_avg, beta,gamma):\n",
    "    kappa = (beta + gamma)*(x/(1-x))\n",
    "    a_over_th = 1/y - 1\n",
    "    theta = np.sqrt(kappa*K_avg/a_over_th)\n",
    "    a = K_avg*kappa/theta\n",
    "    return a,kappa,theta,beta,gamma\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8db66bbf",
   "metadata": {},
   "source": [
    "### The switching model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4e6b8867",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TelegraphModel():\n",
    "    \"\"\"\n",
    "    This collection of convenience functions is placed in its own class mostly to avoid function name conflicts.\n",
    "    The code is largely reused from JJV's thesis and \"Analytic solution of chemical master equations \n",
    "    involving gene switching. I: Representation theory and diagrammatic approach to exact solution.\"\n",
    "    \"\"\"\n",
    "    def __init__(self):\n",
    "        pass\n",
    "\n",
    "\n",
    "    # First ODE for 2 species model\n",
    "    def f1_2sp(self,q1, q2, t, c0, c1, params):\n",
    "        alpha_1, alpha_2, beta_0, beta_1, k_12, k_21 = params[0], params[1], params[2], params[3], params[4], params[5]\n",
    "\n",
    "        result = - k_21*q1 + k_21*q2 + alpha_1*(c0*np.exp(-beta_0*t) + c1*np.exp(-beta_1*t))*q1\n",
    "        return result\n",
    "\n",
    "    # Second ODE for 2 species model\n",
    "    def f2_2sp(self,q1, q2, t, c0, c1, params):\n",
    "        alpha_1, alpha_2, beta_0, beta_1, k_12, k_21 = params[0], params[1], params[2], params[3], params[4], params[5]\n",
    "\n",
    "        result = k_12*q1 - k_12*q2 + alpha_2*(c0*np.exp(-beta_0*t) + c1*np.exp(-beta_1*t))*q2\n",
    "        return result\n",
    "\n",
    "\n",
    "    # RK4 implementation for 2 species model\n",
    "    def RK4_2sp(self,q1, q2, f1_b, f2_b, t, g0, g1, step_size, param):\n",
    "        j1 = f1_b(q1, q2, t, g0, g1, param)\n",
    "        h1 = f2_b(q1, q2, t, g0, g1, param)\n",
    "\n",
    "        j2 = f1_b(q1 + (step_size/2)*j1, q2 + (step_size/2)*h1, t + (step_size/2), g0, g1, param)\n",
    "        h2 = f2_b(q1 + (step_size/2)*j1, q2 + (step_size/2)*h1, t + (step_size/2), g0, g1, param)\n",
    "\n",
    "        j3 = f1_b(q1 + (step_size/2)*j2, q2 + (step_size/2)*h2, t + (step_size/2), g0, g1, param)\n",
    "        h3 = f2_b(q1 + (step_size/2)*j2, q2 + (step_size/2)*h2, t + (step_size/2), g0, g1, param)\n",
    "\n",
    "        j4 = f1_b(q1 + (step_size)*j3, q2 + (step_size)*h3, t + (step_size), g0, g1, param)\n",
    "        h4 = f2_b(q1 + (step_size)*j3, q2 + (step_size)*h3, t + (step_size), g0, g1, param)\n",
    "\n",
    "        q1_new = q1 + (step_size/6)*(j1 + 2*j2 + 2*j3 + j4)\n",
    "        q2_new = q2 + (step_size/6)*(h1 + 2*h2 + 2*h3 + h4)    \n",
    "\n",
    "        return q1_new, q2_new\n",
    "\n",
    "\n",
    "    # Get generating function for 2 species model (unspliced and spliced) via ODE method\n",
    "    def get_gf_bds_2sp_ODE(self,g0, g1, params):\n",
    "        # get parameters\n",
    "        alpha_1, alpha_2, beta_0, beta_1, k_12, k_21 = params[0], params[1], params[2], params[3], params[4], params[5]\n",
    "        s = k_12 + k_21\n",
    "\n",
    "        c0 = (g0) + (beta_0/(beta_1 - beta_0))*(g1)       # q coefficients\n",
    "        c1 = - (beta_0/(beta_1 - beta_0))*(g1)       \n",
    "\n",
    "        max_fudge = 10                                              # Determine integration time scale / length\n",
    "        t_max = np.max([1/beta_0, 1/beta_1])*max_fudge\n",
    "        min_fudge = 1\n",
    "        dt = np.min([1/s, 1/beta_0, 1/beta_1, 1/np.max([alpha_1, alpha_2])])*min_fudge\n",
    "        num_tsteps = int(np.ceil(t_max/dt))\n",
    "\n",
    "\n",
    "        q1 = np.ones(g0.shape, dtype=np.complex64)    # initialize array to store ODE\n",
    "        q2 = np.ones(g0.shape, dtype=np.complex64)\n",
    "\n",
    "        # Solve ODE using RK4\n",
    "        for i in range(0, num_tsteps):\n",
    "            t = i*dt\n",
    "            q1, q2 = self.RK4_2sp(q1, q2, self.f1_2sp, self.f2_2sp, t, c0, c1, dt, params)\n",
    "        gf = (k_12/s)*q1 + (k_21/s)*q2\n",
    "        return gf\n",
    "\n",
    "\n",
    "    # Get Pss for 2 species model (unspliced and spliced) via ODE method\n",
    "    def get_Pss_bds_2sp_ODE(self,mx, params):\n",
    "        # Get generating function argument\n",
    "        u = []\n",
    "        half = mx[:]\n",
    "        half[-1] = mx[-1]//2 + 1\n",
    "        for i in range(len(mx)):\n",
    "            l = np.arange(half[i])\n",
    "            u_ = np.exp(-2j*np.pi*l/mx[i])-1\n",
    "            u.append(u_)\n",
    "        g = np.meshgrid(*[u_ for u_ in u], indexing='ij')\n",
    "        for i in range(len(mx)):\n",
    "            g[i] = g[i].flatten()\n",
    "\n",
    "        # Get generating function\n",
    "        gf = self.get_gf_bds_2sp_ODE(g[0], g[1], params)                    \n",
    "        gf = gf.reshape(tuple(half))\n",
    "\n",
    "\n",
    "        Pss = scipy.fft.irfftn(gf, s=mx)                        # Get Pss by inverse fast Fourier transform\n",
    "        return Pss\n",
    "\n",
    "    def get_Pss(self,kon,koff,kinit,beta,gamma,mx):\n",
    "        params = (kinit,0, beta, gamma, kon, koff)\n",
    "        Pss = self.get_Pss_bds_2sp_ODE(mx, params)\n",
    "        Pss = np.abs(Pss)\n",
    "        Pss /= Pss.sum()\n",
    "        return Pss"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c959684e",
   "metadata": {},
   "source": [
    "### Gamma-OU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ad9a659b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class GOUModel():\n",
    "    \"\"\"\n",
    "    This collection of convenience functions is largely reused from \n",
    "    \"Interpretable and tractable models of transcriptional noise for the \n",
    "    rational design of single-molecule quantification experiments\".\n",
    "    \"\"\"\n",
    "    def __init__(self):\n",
    "        pass\n",
    "    def get_GOU_2sp(self,mx, params):\n",
    "        u = []\n",
    "        half = mx[:]\n",
    "        half[-1] = mx[-1]//2 + 1\n",
    "        for i in range(len(mx)):\n",
    "            l = np.arange(half[i])\n",
    "            u_ = np.exp(-2j*np.pi*l/mx[i])-1\n",
    "            u.append(u_)\n",
    "        g = np.meshgrid(*[u_ for u_ in u], indexing='ij')\n",
    "        for i in range(len(mx)):\n",
    "            g[i] = g[i].flatten()\n",
    "\n",
    "        # Get generating function\n",
    "        gf = self.get_gf_GOU_2sp_ODE(g[0], g[1], params)                    \n",
    "        gf = gf.reshape(tuple(half))\n",
    "\n",
    "        Pss = scipy.fft.irfftn(gf, s=mx)                        # Get Pss by inverse fast Fourier transform\n",
    "        Pss = np.abs(Pss)/np.sum(np.abs(Pss))           # Normalize\n",
    "        return Pss\n",
    "\n",
    "    def get_gf_GOU_2sp_ODE(self,g0, g1, params):\n",
    "        beta_0, beta_1, a, kappa, theta = params     # get parameters\n",
    "\n",
    "        c0 = (g0) + (beta_0/(beta_1 - beta_0))*(g1)       #  relevant linear combinations of g_i\n",
    "        c1 = - (beta_0/(beta_1 - beta_0))*(g1)   \n",
    "\n",
    "        min_fudge, max_fudge = 0.25, 10                                     # Determine integration time scale / length\n",
    "        dt = np.min([1/kappa, 1/theta, 1/a, 1/beta_0, 1/beta_1])*min_fudge\n",
    "        t_max = np.max([1/kappa, 1/theta, 1/a, 1/beta_0, 1/beta_1])*max_fudge\n",
    "        num_tsteps = int(np.ceil(t_max/dt))\n",
    "        t_array = np.linspace(0, t_max, num_tsteps+1)\n",
    "        t_array = t_array.reshape((1, num_tsteps + 1))\n",
    "\n",
    "        q = np.zeros((g0.shape[0], num_tsteps + 1), dtype=np.complex64)    # initialize array to store ODE\n",
    "        c0 = c0.reshape((c0.shape[0],1))\n",
    "        c1 = c1.reshape((c1.shape[0],1))\n",
    "        q0 = theta*c0*(np.exp(-beta_0*t_array) - np.exp(-kappa*t_array))/(kappa - beta_0) \n",
    "        q1 = theta*c1*(np.exp(-beta_1*t_array) - np.exp(-kappa*t_array))/(kappa - beta_1)\n",
    "        q = q0 + q1\n",
    "\n",
    "\n",
    "        integrand = q/(1-q)\n",
    "        integral = np.trapz(integrand, dx=dt, axis=1)     # integrate ODE solution\n",
    "        gf = np.exp( a*integral)               # get generating function\n",
    "        return gf\n",
    "    \n",
    "    def get_Pss(self,a,kappa,theta,beta,gamma,mx):\n",
    "        params = beta, gamma, a, kappa, theta\n",
    "        if np.any((np.asarray(params)<=0) | (~np.isfinite(params))):\n",
    "            raise ValueError\n",
    "\n",
    "        Pss = self.get_GOU_2sp(mx, params)\n",
    "        Pss = np.abs(Pss)\n",
    "        Pss /= Pss.sum()\n",
    "        return Pss"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f31380e4",
   "metadata": {},
   "source": [
    "### CIR "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5345f67c",
   "metadata": {},
   "outputs": [],
   "source": [
    "class CIRModel():\n",
    "    \"\"\"\n",
    "    This collection of convenience functions is largely reused from \n",
    "    \"Interpretable and tractable models of transcriptional noise for the \n",
    "    rational design of single-molecule quantification experiments\".\n",
    "    \"\"\"\n",
    "    def __init__(self):\n",
    "        pass\n",
    "    # ODE for 2 species CIR model\n",
    "    def f_2sp(self,q, t, c0, c1, params):\n",
    "        beta_0, beta_1, a, kappa, theta = params\n",
    "        result = - kappa*q + theta*q*q + kappa*( c0*np.exp(-beta_0*t) + c1*np.exp(-beta_1*t)  ) \n",
    "        return result\n",
    "\n",
    "\n",
    "    # Vectorized RK4 implementation for 2 species CIR model\n",
    "    def RK4_2sp(self,q, f, t, c0, c1, step_size, param):\n",
    "        j1 = f(q, t, c0, c1, param)\n",
    "        j2 = f(q + (step_size/2)*j1, t + (step_size/2), c0, c1, param)   \n",
    "        j3 = f(q + (step_size/2)*j2, t + (step_size/2), c0, c1, param)   \n",
    "        j4 = f(q + (step_size)*j3, t + (step_size), c0, c1, param)  \n",
    "\n",
    "        q_new = q + (step_size/6)*(j1 + 2*j2 + 2*j3 + j4)\n",
    "        return q_new\n",
    "\n",
    "\n",
    "    # Get 2 species CIR generating function using ODE method\n",
    "    def get_gf_CIR_2sp(self,g0, g1, params):\n",
    "        beta_0, beta_1, a, kappa, theta = params     # get parameters\n",
    "\n",
    "        c0 = (g0) + (beta_0/(beta_1 - beta_0))*(g1)       #  relevant linear combinations of g_i\n",
    "        c1 = - (beta_0/(beta_1 - beta_0))*(g1)   \n",
    "\n",
    "        min_fudge, max_fudge = 0.25, 10                                     # Determine integration time scale / length\n",
    "        dt = np.min([1/kappa, 1/theta, 1/a, 1/beta_0, 1/beta_1])*min_fudge\n",
    "        t_max = np.max([1/kappa, 1/theta, 1/a, 1/beta_0, 1/beta_1])*max_fudge\n",
    "        num_tsteps = int(np.ceil(t_max/dt))\n",
    "\n",
    "        q = np.zeros((g0.shape[0], num_tsteps + 1), dtype=np.complex64)    # initialize array to store ODE\n",
    "\n",
    "        # Solve ODE using RK4 method \n",
    "        for i in range(0, num_tsteps):\n",
    "            t = i*dt\n",
    "            q[:,i+1] = self.RK4_2sp(q[:,i], self.f_2sp, t, c0, c1, dt, params)\n",
    "\n",
    "        integral = np.trapz(q, dx=dt, axis=1)     # integrate ODE solution\n",
    "        gf = np.exp((a*theta/kappa)*integral)               # get generating function\n",
    "        return gf\n",
    "\n",
    "\n",
    "    # Get Pss for 2 species CIR model via ODE method\n",
    "    def get_CIR_2sp(self,mx,params):\n",
    "        # Get generating function argument\n",
    "        u = []\n",
    "        half = mx[:]\n",
    "        half[-1] = mx[-1]//2 + 1\n",
    "        for i in range(len(mx)):\n",
    "            l = np.arange(half[i])\n",
    "            u_ = np.exp(-2j*np.pi*l/mx[i])-1\n",
    "            u.append(u_)\n",
    "        g = np.meshgrid(*[u_ for u_ in u], indexing='ij')\n",
    "        for i in range(len(mx)):\n",
    "            g[i] = g[i].flatten()\n",
    "\n",
    "        # Get generating function\n",
    "        gf = self.get_gf_CIR_2sp(g[0], g[1], params)                    \n",
    "        gf = gf.reshape(tuple(half))\n",
    "\n",
    "        Pss = scipy.fft.irfftn(gf, s=mx)                        # Get Pss by inverse fast Fourier transform\n",
    "#         Pss = np.abs(Pss)/np.sum(np.abs(Pss))           # Normalize\n",
    "        return Pss\n",
    "\n",
    "    def get_Pss(self,a,kappa,theta,beta,gamma,mx):\n",
    "        params = beta, gamma, a, kappa, theta\n",
    "        if np.any((np.asarray(params)<=0) | (~np.isfinite(params))):\n",
    "            raise ValueError\n",
    "        Pss = self.get_CIR_2sp(mx, params)\n",
    "        Pss = np.abs(Pss)\n",
    "        Pss /= Pss.sum()\n",
    "        return Pss"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbadf183",
   "metadata": {},
   "source": [
    "### Basic tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "25096736",
   "metadata": {},
   "outputs": [],
   "source": [
    "kon = 0.2\n",
    "koff = 0.2\n",
    "kinit = 10\n",
    "beta = 1.2\n",
    "gamma = 0.7\n",
    "mx = [50,1]\n",
    "x = np.arange(mx[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "418c8bed",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.166666666666667"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kon*kinit/beta/(kon+koff)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f826dfce",
   "metadata": {},
   "outputs": [],
   "source": [
    "kappa = kon+koff\n",
    "a = kon*kappa/koff\n",
    "theta = koff*kinit/kappa\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "4f725642",
   "metadata": {},
   "outputs": [],
   "source": [
    "telegraph_model = TelegraphModel()\n",
    "Pss_tele = telegraph_model.get_Pss(kon,koff,kinit,beta,gamma,mx)\n",
    "gou_model = GOUModel()\n",
    "Pss_gou = gou_model.get_Pss(a,kappa,theta,beta,gamma,mx)\n",
    "cir_model = CIRModel()\n",
    "Pss_cir = cir_model.get_Pss(a,kappa,theta,beta,gamma,mx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "a28d49b5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fbe557ce2e0>]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(Pss_tele)\n",
    "plt.plot(Pss_gou)\n",
    "plt.plot(Pss_cir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "6d9b3ab5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.166666819545542\n",
      "4.165914645377943\n",
      "4.165691387137144\n"
     ]
    }
   ],
   "source": [
    "print((Pss_tele.sum(1)*x).sum())\n",
    "print((Pss_gou.sum(1)*x).sum())\n",
    "print((Pss_cir.sum(1)*x).sum())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "5fb6c6eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17.187487995048926\n",
      "17.18435841299372\n",
      "17.17146794619267\n"
     ]
    }
   ],
   "source": [
    "print((Pss_tele.sum(1)*x**2).sum() - (Pss_tele.sum(1)*x).sum()**2)\n",
    "print((Pss_gou.sum(1)*x**2).sum() - (Pss_gou.sum(1)*x).sum()**2)\n",
    "print((Pss_cir.sum(1)*x**2).sum() - (Pss_cir.sum(1)*x).sum()**2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e01c783",
   "metadata": {},
   "source": [
    "### Sampling and evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "1619abec",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sample_from_p(num_data_points, Pss):\n",
    "    mx = Pss.shape\n",
    "    p_flat = Pss.flatten()\n",
    "    x_N, x_M = np.arange(mx[0]), np.arange(mx[1])\n",
    "    X_N, X_M = np.meshgrid(x_N, x_M, indexing='ij')    # get grid of possible values\n",
    "    x_choices = np.arange(np.prod(mx))                 # represent each grid point as a point in a 1D vector\n",
    "    \n",
    "    samples = np.random.choice(x_choices, size=num_data_points, replace=True, p=p_flat)\n",
    "    d_N, d_M = X_N.flatten()[samples], X_M.flatten()[samples]    \n",
    "    return d_N, d_M\n",
    "\n",
    "def get_logL_1d(d,x,y,K_avg,beta,xyfun,model,mx,dryrun=False):\n",
    "    mx_eval = [mx[0],1]\n",
    "    pars = xyfun(x,y,K_avg,beta)\n",
    "    if dryrun:\n",
    "        print(pars)\n",
    "        return 0\n",
    "    Pss = model.get_Pss(*pars,1,mx_eval)\n",
    "    Pss = Pss.squeeze()\n",
    "    logL = np.sum(np.log(Pss[d]))\n",
    "    return logL\n",
    "\n",
    "\n",
    "def get_logL_2d(d0,d1,x,y,K_avg,beta,gamma,xyfun,model,mx,dryrun=False):\n",
    "    mx_eval = mx\n",
    "    pars = xyfun(x,y,K_avg,beta,gamma)\n",
    "    if dryrun:\n",
    "        print(pars)\n",
    "        return 0\n",
    "    Pss = model.get_Pss(*pars,mx_eval)\n",
    "    Pss = Pss.squeeze()\n",
    "    logL = np.sum(np.log(Pss[d0,d1]))\n",
    "    return logL"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d619616",
   "metadata": {},
   "source": [
    "# Parameter regimes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "c505879f",
   "metadata": {},
   "outputs": [],
   "source": [
    "kappa = 0.1\n",
    "beta = 0.8 \n",
    "gamma = 0.9\n",
    "theta = 1\n",
    "a = 0.4\n",
    "mx = [50,51]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "23835bf0",
   "metadata": {},
   "outputs": [],
   "source": [
    "gou_model = GOUModel()\n",
    "Pss_gou_true = gou_model.get_Pss(a,kappa,theta,beta,gamma,mx)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "02b67f20",
   "metadata": {},
   "outputs": [],
   "source": [
    "xtrue1,ytrue1,K_avg,beta = encode_xy_sde_1d(a, kappa, theta,beta)\n",
    "xtrue2,ytrue2,K_avg,beta,gamma = encode_xy_sde_2d(a, kappa, theta,beta,gamma)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "9175ab17",
   "metadata": {},
   "outputs": [],
   "source": [
    "nCells = 200\n",
    "nTrials = 1\n",
    "num_data_points = (nCells,nTrials)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "fa2d52e8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "K_avg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "25c48231",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fbe53018cd0>]"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(Pss_gou_true.sum(0))\n",
    "plt.plot(Pss_gou_true.sum(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "d034deb7",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = sample_from_p(num_data_points,Pss_gou_true) #don't rerun this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "51d77824",
   "metadata": {},
   "outputs": [],
   "source": [
    "nX = 14\n",
    "nY = 15\n",
    "x_ = np.linspace(0.01,0.99,nX)\n",
    "y_ = np.linspace(0.01,0.99,nY)\n",
    "X,Y = np.meshgrid(x_,y_,indexing='ij')\n",
    "logL_1d = np.zeros((nX,nY))\n",
    "logL_2d = np.zeros((nX,nY))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "255b5df0",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# for i,x in enumerate(x_):\n",
    "#     for j,y in enumerate(y_):\n",
    "#         logL_1d[i,j] = get_logL_1d(data[0][:,0],x,y,K_avg,beta,decode_xy_sde_1d,gou_model,mx)\n",
    "#         logL_2d[i,j] = get_logL_2d(data[0][:,0],data[1][:,0],x,y,K_avg,beta,gamma,decode_xy_sde_2d,gou_model,mx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "edbf1a19",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import pickle\n",
    "# with open('./data/gg230221_logLs.pickle', \"wb\") as logLfs:\n",
    "#     pickle.dump((logL_1d,logL_2d), logLfs)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "id": "2707f4db",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "with open('./data/gg230221_logLs.pickle', \"rb\") as logLfs:\n",
    "    (logL_1d,logL_2d) = pickle.load( logLfs)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "id": "0f9ea2db",
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib.colors import ListedColormap,LinearSegmentedColormap\n",
    "from matplotlib.patches import Rectangle\n",
    "\n",
    "# c1 = [0,0,0,0]\n",
    "# # c2 = [1,1,1,1]\n",
    "# c2 = [235/255,228/255,143/255,1]\n",
    "# ncol=2\n",
    "# cmap_highlight = ListedColormap(np.array([np.linspace(c2[j],c1[j],ncol) for j in range(4)]).T)\n",
    "colors = [(1,0,0,c) for c in np.linspace(0,1,100)]\n",
    "cmap_highlight = LinearSegmentedColormap.from_list('mycmap', colors, N=5)\n",
    "\n",
    "cmap_logl = 'cividis'\n",
    "# color_highlight = cmap_highlight\n",
    "fs = 12\n",
    "colors_transp = [(1,1,1,c) for c in np.linspace(1,1,100)]\n",
    "cmap_highlight = LinearSegmentedColormap.from_list('mycmap', colors_transp, N=5)\n",
    "regime_ms = 300\n",
    "\n",
    "dim_names = ('Timescale separation','Noise intensity')\n",
    "# dim_names = (r'$\\frac{\\kappa}{\\kappa + \\beta}$',r'$\\frac{\\theta}{\\theta + a}$')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "id": "1212c429",
   "metadata": {},
   "outputs": [],
   "source": [
    "from mpl_toolkits.axes_grid1 import make_axes_locatable\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "id": "fe73bcc0",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib\n",
    "c_coord = 0.7\n",
    "c_true = matplotlib.colormaps['Reds'](c_coord)[:3]\n",
    "c_false =  matplotlib.colormaps['Blues'](c_coord)[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "id": "df2b4e3d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x288 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig1,ax1 = plt.subplots(1,4,figsize=(16,4))\n",
    "vmin,vmax = (logL_1d.min(),logL_1d.max())\n",
    "ax1[0].pcolormesh(X,Y,(logL_1d),cmap=cmap_logl,vmin=vmin,vmax=vmax)\n",
    "q = np.quantile(logL_1d,0.9)\n",
    "ax1[0].pcolor(X,Y,np.ma.masked_array(logL_1d,logL_1d<q),\n",
    "              cmap=cmap_logl,\n",
    "              alpha=1,hatch='///',edgecolor='magenta',facecolor=None,linewidth=0,\n",
    "              vmin=vmin,vmax=vmax)\n",
    "# ax1[0].pcolormesh(X,Y,np.ma.masked_array(logL_1d,logL_1d<q),cmap=cmap_highlight,alpha=0.5)\n",
    "ax1[0].scatter(xtrue1,ytrue1,regime_ms,color=c_true,edgecolors='k')\n",
    "\n",
    "xfalse1 = 0.9\n",
    "yfalse1 = ytrue1\n",
    "ax1[0].scatter(xfalse1,yfalse1,regime_ms,color=c_false,edgecolors='k')\n",
    "ax1[0].set_title(r'$\\log L$ with one species',fontsize=fs)\n",
    "ax1[0].set_xlabel(dim_names[0],fontsize=fs)\n",
    "ax1[0].set_ylabel(dim_names[1],fontsize=fs)\n",
    "\n",
    "##################################\n",
    "xfalse2,yfalse2,K_avg,beta,gamma =  encode_xy_sde_2d(*decode_xy_sde_1d(xfalse1,yfalse1,K_avg,beta),gamma)\n",
    "\n",
    "vmin,vmax = (logL_2d.min(),logL_2d.max())\n",
    "mesh = ax1[1].pcolormesh(X,Y,(logL_2d),cmap=cmap_logl,vmin=vmin,vmax=vmax)\n",
    "q = np.quantile(logL_2d,0.9)\n",
    "ax1[1].pcolor(X,Y,np.ma.masked_array(logL_2d,logL_2d<q),\n",
    "              cmap=cmap_logl,\n",
    "              alpha=1,hatch='///',edgecolor='magenta',facecolor=None,linewidth=0,\n",
    "              vmin=vmin,vmax=vmax)\n",
    "ax1[1].scatter(xtrue2,ytrue2,regime_ms,color=c_true,edgecolors='k')\n",
    "ax1[1].scatter(xfalse2,yfalse2,regime_ms,color=c_false,edgecolors='k')\n",
    "ax1[1].set_title(r'$\\log L$ with two species',fontsize=fs)\n",
    "ax1[1].set_xlabel(dim_names[0],fontsize=fs)\n",
    "ax1[1].set_ylabel(dim_names[1],fontsize=fs)\n",
    "\n",
    "\n",
    "divider = make_axes_locatable(ax1[1])\n",
    "# cax = divider.append_axes('right', size='10%', pad=0.05)\n",
    "cax = divider.append_axes('right', size='5%', pad=0.05)\n",
    "# cax.plot([0,1],[1/3]*2,'w',linewidth=3)\n",
    "# cax.plot([0,1],[1/2]*2,'w',linewidth=3)\n",
    "fig1.colorbar(mesh,cax =cax)\n",
    "cax.set_ylabel(r'$\\log L$ relative to range',fontsize=fs)\n",
    "caxlims = np.asarray([logL_2d.min(),logL_2d.max()])\n",
    "# print([caxlims[0],caxlims.mean(), np.diff(caxlims)[0]*0.9+caxlims[0], caxlims[1]])\n",
    "dl = np.diff(caxlims)[0]\n",
    "cax.set_yticks([caxlims[0],caxlims.mean(), dl*0.9+caxlims[0], caxlims[1]],['0%','50%','90%','100%'])\n",
    "cax.add_patch(Rectangle((0, dl*0.9+caxlims[0]), 1, dl*0.1, fill=False, hatch='///',edgecolor='magenta'))\n",
    "\n",
    "# cax.plot(Pvals_true,xvals,'r')\n",
    "# cax.plot(Pvals_false,xvals,'b')\n",
    "# cax_mx = max(Pvals_false.max(),Pvals_true.max())\n",
    "# cax.set_xlim([0,cax_mx*1.5])\n",
    "# cax.invert_xaxis()\n",
    "# cax.set_xticks([])\n",
    "# cax.set_yticks(np.arange(0,21,5))\n",
    "# cax.set_ylabel('# nascent',fontsize=fs\n",
    "\n",
    "################################\n",
    "Pss_gou_false = gou_model.get_Pss(*decode_xy_sde_2d(xfalse2,yfalse2,K_avg,beta,gamma),mx)\n",
    "\n",
    "xvals = np.arange(mx[0])\n",
    "Pvals_true = Pss_gou_true.sum(1)\n",
    "Pvals_false = Pss_gou_false.sum(1)\n",
    "\n",
    "divider = make_axes_locatable(ax1[2])\n",
    "cax = divider.append_axes('left', size='10%', pad=0.05)\n",
    "\n",
    "cax.barh(xvals,Pvals_true,color=c_true,align='center',alpha=0.4)\n",
    "cax.barh(xvals,Pvals_false,color=c_false,align='center',alpha=0.4)\n",
    "# cax.plot(Pvals_true,xvals,color=c_true)\n",
    "# cax.plot(Pvals_false,xvals,color=c_false,linestyle='--')\n",
    "cax_mx = max(Pvals_false.max(),Pvals_true.max())\n",
    "cax.set_xlim([0,cax_mx*1.5])\n",
    "cax.invert_xaxis()\n",
    "cax.set_xticks([])\n",
    "cax.set_yticks(np.arange(0,21,5))\n",
    "cax.set_ylabel('# nascent',fontsize=fs)\n",
    "\n",
    "\n",
    "ax1[2].imshow((Pss_gou_true),cmap='Reds',aspect='auto')\n",
    "ax1[2].invert_yaxis()\n",
    "ax1[2].set_yticks([])\n",
    "ax1[2].set_xlabel('# mature',fontsize=fs)\n",
    "ax1[2].set_title('Mixture-like regime',fontsize=fs,color=c_true)\n",
    "\n",
    "\n",
    "ax1[3].imshow((Pss_gou_false),cmap='Blues',aspect='auto')\n",
    "ax1[3].invert_yaxis()\n",
    "ax1[3].set_yticks([])\n",
    "ax1[3].set_xlabel('# mature',fontsize=fs)\n",
    "ax1[3].set_title('Burst-like regime',fontsize=fs,color=c_false)\n",
    "\n",
    "\n",
    "lims = [-0.5,20]\n",
    "ax1[2].set_xlim(lims)\n",
    "ax1[2].set_ylim(lims)\n",
    "ax1[3].set_xlim(lims)\n",
    "ax1[3].set_ylim(lims)\n",
    "cax.set_ylim(lims)\n",
    "\n",
    "fig1.tight_layout()\n",
    "plt.savefig('figs/fig3b.png',dpi=450)\n",
    "plt.savefig('figs/fig3b.pdf')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72b633d9",
   "metadata": {},
   "source": [
    "# AIC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "id": "a2cf0eb5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# kappa = 0.1\n",
    "beta = 0.8 \n",
    "gamma = 0.9\n",
    "# theta = 1\n",
    "# a = 0.4\n",
    "mx = [50,51]\n",
    "K_avg = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "id": "a3def76b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings(\"error\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "id": "0bf69246",
   "metadata": {},
   "outputs": [],
   "source": [
    "nCells = 200\n",
    "nTrials = 50\n",
    "num_data_points = (nCells,nTrials)\n",
    "telegraph_model = TelegraphModel()\n",
    "gou_model = GOUModel()\n",
    "cir_model = CIRModel()\n",
    "model_names = (r'$\\Gamma$-OU','CIR','Telegraph')\n",
    "models = [gou_model, cir_model, telegraph_model]\n",
    "decode_fun_1d = [decode_xy_sde_1d,decode_xy_sde_1d,decode_xy_tele_1d]\n",
    "decode_fun_2d = [decode_xy_sde_2d,decode_xy_sde_2d,decode_xy_tele_2d]\n",
    "true_model = models[0]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "id": "3b9c62af",
   "metadata": {},
   "outputs": [],
   "source": [
    "# nX = 4\n",
    "# nY = 5\n",
    "nX = 14\n",
    "nY = 15\n",
    "x_ = np.linspace(0.01,0.99,nX)\n",
    "y_ = np.linspace(0.01,0.99,nY)\n",
    "nmod = 3\n",
    "Xaic,Yaic = np.meshgrid(x_,y_,indexing='ij')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "06e7a346",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "# logL_1d_AIC = np.zeros((nX,nY,nmod,nTrials))\n",
    "# logL_2d_AIC = np.zeros((nX,nY,nmod,nTrials))\n",
    "# dryrun=False\n",
    "# for i,x in enumerate(x_):\n",
    "#     print(i)\n",
    "#     for j,y in enumerate(y_):\n",
    "#         Pss_true = true_model.get_Pss(*decode_xy_sde_2d(x,y,K_avg,beta,gamma),mx)\n",
    "#         data = sample_from_p(num_data_points,Pss_true)\n",
    "#         for k in range(nmod):\n",
    "#             for trial in range(nTrials):\n",
    "#                 logL_1d_AIC[i,j,k,trial] = get_logL_1d(data[0][:,trial],x,y,K_avg,beta,decode_fun_1d[k],models[k],mx,dryrun=dryrun)                \n",
    "#                 logL_2d_AIC[i,j,k,trial] = get_logL_2d(data[0][:,trial],data[1][:,trial],x,y,K_avg,beta,gamma,decode_fun_2d[k],models[k],mx,dryrun=dryrun)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "f3564a34",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "04855140",
   "metadata": {},
   "outputs": [],
   "source": [
    "# with open('./data/gg230221_aics_50trials.pickle', \"wb\") as aicfs:\n",
    "#     pickle.dump((logL_1d_AIC,logL_2d_AIC), aicfs)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "id": "01be1366",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('./data/gg230221_aics_50trials.pickle', \"rb\") as aicfs:\n",
    "    logL_1d_AIC,logL_2d_AIC  = pickle.load(aicfs)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "id": "cd01925a",
   "metadata": {},
   "outputs": [],
   "source": [
    "AIC_values = -2*logL_1d_AIC \n",
    "AICmin = np.amin(AIC_values,2)\n",
    "dAIC = AIC_values-AICmin[:,:,None,:]\n",
    "AIC = np.exp(-dAIC/2)\n",
    "AIC /= AIC.sum(2)[:,:,None,:]\n",
    "Z_1d = AIC[:,:,0,:].mean(-1)\n",
    "\n",
    "AIC_values = -2*logL_2d_AIC \n",
    "AICmin = np.amin(AIC_values,2)\n",
    "dAIC = AIC_values-AICmin[:,:,None,:]\n",
    "AIC = np.exp(-dAIC/2)\n",
    "AIC /= AIC.sum(2)[:,:,None,:]\n",
    "Z_2d = AIC[:,:,0,:].mean(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "id": "670368fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import colors\n",
    "\n",
    "cmap_aic = 'plasma'\n",
    "fs = 12\n",
    "cmap = colors.ListedColormap(['white', 'magenta','blue'])\n",
    "bounds=[0,1/3,1/2,1]\n",
    "norm = colors.BoundaryNorm(bounds, cmap.N)\n",
    "\n",
    "model_colors = ['cadetblue','limegreen','goldenrod']\n",
    "regime_colors = ['darkolivegreen','deeppink']\n",
    "regime_ms = 300\n",
    "noise_ms = 100\n",
    "noise_color='darkgray'\n",
    "noiseline_colors = ['darkgray','dimgray']\n",
    "noiseline_width = [3,5]\n",
    "head_width=0.03\n",
    "import matplotlib.patheffects as pe\n",
    "from matplotlib.patches import Rectangle\n",
    "pvals = [1,0.5,0.25,0.15]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "id": "c55cbe0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "warnings.resetwarnings()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "id": "e8682a9b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x288 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig1,ax1 = plt.subplots(1,4,figsize=(16,4))\n",
    "\n",
    "mesh = ax1[0].pcolormesh(Xaic,Yaic,Z_1d,cmap=cmap_aic,vmin=0,vmax=1)\n",
    "ax1[0].pcolor(Xaic,Yaic,np.ma.masked_array(Z_1d,Z_1d>1/2),\n",
    "              cmap=cmap_aic,\n",
    "              alpha=1,hatch='\\\\\\\\',edgecolor='black',facecolor=None,linewidth=0,\n",
    "              vmin=0,vmax=1)\n",
    "\n",
    "\n",
    "x1_1d = 0.4\n",
    "y1_1d = 0.9\n",
    "\n",
    "x2_1d = 0.9\n",
    "y2_1d = 0.8\n",
    "\n",
    "ax1[0].set_xlabel(dim_names[0],fontsize=fs)\n",
    "ax1[0].set_ylabel(dim_names[1],fontsize=fs)\n",
    "ax1[0].set_title('AIC weight with one species',fontsize=fs)\n",
    "################\n",
    "pars_1 = decode_xy_sde_1d(x1_1d,y1_1d,K_avg,beta)\n",
    "noise_corr_1 = []\n",
    "for p_val in pvals:\n",
    "    pars_new = np.copy(pars_1)\n",
    "    pars_new[0] /= p_val\n",
    "    pars_new[2] *= p_val\n",
    "    x,y,_,_ = encode_xy_sde_1d(*pars_new)\n",
    "    noise_corr_1.append([x,y])\n",
    "noise_corr_1 = np.asarray(noise_corr_1)\n",
    "ax1[0].plot(noise_corr_1[:,0],noise_corr_1[:,1],'-',\n",
    "            linewidth=noiseline_width[0],color=noiseline_colors[0],\n",
    "            path_effects=[pe.Stroke(linewidth=noiseline_width[1], foreground=noiseline_colors[1]), pe.Normal()])\n",
    "ax1[0].arrow(noise_corr_1[-1,0],noise_corr_1[-1,1],0,-noise_corr_1[-1,1],\n",
    "            head_width = head_width,\n",
    "            linewidth=noiseline_width[0],color=noiseline_colors[0],\n",
    "            path_effects=[pe.Stroke(linewidth=noiseline_width[1], foreground=noiseline_colors[1]), pe.Normal()],\n",
    "            length_includes_head=True)\n",
    "ax1[0].scatter(noise_corr_1[1:,0],noise_corr_1[1:,1],s=noise_ms,c=regime_colors[0],edgecolors='k',zorder=1000)\n",
    "#########\n",
    "pars_2 = decode_xy_sde_1d(x2_1d,y2_1d,K_avg,beta)\n",
    "noise_corr_2 = []\n",
    "for p_val in pvals:\n",
    "    pars_new = np.copy(pars_2)\n",
    "    pars_new[0] /= p_val\n",
    "    pars_new[2] *= p_val\n",
    "    x,y,_,_ = encode_xy_sde_1d(*pars_new)\n",
    "    noise_corr_2.append([x,y])\n",
    "noise_corr_2 = np.asarray(noise_corr_2)\n",
    "ax1[0].plot(noise_corr_2[:,0],noise_corr_2[:,1],'-',\n",
    "            linewidth=noiseline_width[0],color=noiseline_colors[0],\n",
    "            path_effects=[pe.Stroke(linewidth=noiseline_width[1], foreground=noiseline_colors[1]), pe.Normal()])\n",
    "ax1[0].arrow(noise_corr_2[-1,0],noise_corr_2[-1,1],0,-noise_corr_2[-1,1],\n",
    "            head_width = head_width,\n",
    "            linewidth=noiseline_width[0],color=noiseline_colors[0],\n",
    "            path_effects=[pe.Stroke(linewidth=noiseline_width[1], foreground=noiseline_colors[1]), pe.Normal()],\n",
    "            length_includes_head=True)\n",
    "ax1[0].scatter(noise_corr_2[1:,0],noise_corr_2[1:,1],s=noise_ms,c=regime_colors[1],edgecolors='k',zorder=1000)\n",
    "#########\n",
    "ax1[0].scatter(x1_1d,y1_1d,regime_ms,regime_colors[0],edgecolors='k',zorder=1000)\n",
    "ax1[0].scatter(x2_1d,y2_1d,regime_ms,regime_colors[1],edgecolors='k',zorder=1000)\n",
    "#########\n",
    "\n",
    "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
    "divider = make_axes_locatable(ax1[1])\n",
    "cax = divider.append_axes('right', size='5%', pad=0.05)\n",
    "cax.plot([0,1],[1/3]*2,'w',linewidth=3)\n",
    "cax.plot([0,1],[1/2]*2,'w',linewidth=3)\n",
    "fig1.colorbar(mesh,cax =cax)\n",
    "cax.add_patch(Rectangle((0, 0), 1, 1/2, fill=False, hatch='\\\\\\\\'))\n",
    "\n",
    "# ####################################\n",
    "\n",
    "ax1[1].set_title('AIC weight with two species',fontsize=fs)\n",
    "\n",
    "ax1[1].pcolormesh(Xaic,Yaic,Z_2d,cmap=cmap_aic,vmin=0,vmax=1)\n",
    "ax1[1].pcolor(Xaic,Yaic,np.ma.masked_array(Z_2d,Z_2d>1/2),\n",
    "              cmap=cmap_aic,\n",
    "              alpha=1,hatch='\\\\\\\\',edgecolor='black',facecolor=None,linewidth=0,\n",
    "              vmin=0,vmax=1)\n",
    "\n",
    "x1_2d,y1_2d,_,_,_ =  encode_xy_sde_2d(*decode_xy_sde_1d(x1_1d,y1_1d,K_avg,beta),gamma)\n",
    "x2_2d,y2_2d,_,_,_ =  encode_xy_sde_2d(*decode_xy_sde_1d(x2_1d,y2_1d,K_avg,beta),gamma)\n",
    "################\n",
    "pars_1 = decode_xy_sde_1d(x1_2d,y1_2d,K_avg,beta)\n",
    "noise_corr_1 = []\n",
    "for p_val in pvals:\n",
    "    pars_new = np.copy(pars_1)\n",
    "    pars_new[0] /= p_val\n",
    "    pars_new[2] *= p_val\n",
    "    x,y,_,beta = encode_xy_sde_1d(*pars_new)\n",
    "    noise_corr_1.append([x,y])\n",
    "noise_corr_1 = np.asarray(noise_corr_1)\n",
    "ax1[1].plot(noise_corr_1[:,0],noise_corr_1[:,1],'-',\n",
    "            linewidth=noiseline_width[0],color=noiseline_colors[0],\n",
    "            path_effects=[pe.Stroke(linewidth=noiseline_width[1], foreground=noiseline_colors[1]), pe.Normal()])\n",
    "ax1[1].arrow(noise_corr_1[-1,0],noise_corr_1[-1,1],0,-noise_corr_1[-1,1],\n",
    "            head_width = head_width,\n",
    "            linewidth=noiseline_width[0],color=noiseline_colors[0],\n",
    "            path_effects=[pe.Stroke(linewidth=noiseline_width[1], foreground=noiseline_colors[1]), pe.Normal()],\n",
    "            length_includes_head=True)\n",
    "ax1[1].scatter(noise_corr_1[1:,0],noise_corr_1[1:,1],s=noise_ms,c=regime_colors[0],edgecolors='k',zorder=1000)\n",
    "#########\n",
    "pars_2 = decode_xy_sde_1d(x2_2d,y2_2d,K_avg,beta)\n",
    "noise_corr_2 = []\n",
    "for p_val in pvals:\n",
    "    pars_new = np.copy(pars_2)\n",
    "    pars_new[0] /= p_val\n",
    "    pars_new[2] *= p_val\n",
    "    x,y,_,_ = encode_xy_sde_1d(*pars_new)\n",
    "    noise_corr_2.append([x,y])\n",
    "noise_corr_2 = np.asarray(noise_corr_2)\n",
    "ax1[1].plot(noise_corr_2[:,0],noise_corr_2[:,1],'-',\n",
    "            linewidth=noiseline_width[0],color=noiseline_colors[0],\n",
    "            path_effects=[pe.Stroke(linewidth=noiseline_width[1], foreground=noiseline_colors[1]), pe.Normal()])\n",
    "ax1[1].arrow(noise_corr_2[-1,0],noise_corr_2[-1,1],0,-noise_corr_2[-1,1],\n",
    "            head_width = head_width,\n",
    "            linewidth=noiseline_width[0],color=noiseline_colors[0],\n",
    "            path_effects=[pe.Stroke(linewidth=noiseline_width[1], foreground=noiseline_colors[1]), pe.Normal()],\n",
    "            length_includes_head=True)\n",
    "ax1[1].scatter(noise_corr_2[1:,0],noise_corr_2[1:,1],s=noise_ms,c=regime_colors[1],edgecolors='k',zorder=1000)\n",
    "#########\n",
    "ax1[1].scatter(x1_2d,y1_2d,regime_ms,regime_colors[0],edgecolors='k',zorder=1000)\n",
    "ax1[1].scatter(x2_2d,y2_2d,regime_ms,regime_colors[1],edgecolors='k',zorder=1000)\n",
    "#########\n",
    "\n",
    "ax1[1].set_xlabel(dim_names[0],fontsize=fs)\n",
    "ax1[1].set_ylabel(dim_names[1],fontsize=fs)\n",
    "# #####################################\n",
    "\n",
    "xvals = np.arange(mx[0])\n",
    "Pss_arr_1 = [models[k].get_Pss(*decode_fun_2d[k](x1_2d,y1_2d,K_avg,beta,gamma),[mx[0],1]) for  k in range(nmod)]\n",
    "for k in range(3):\n",
    "    ax1[2].plot(xvals,Pss_arr_1[k],label=model_names[k],linewidth=2,color=model_colors[k])\n",
    "ax1[2].legend(fontsize=fs)\n",
    "ax1[2].set_xlabel('# nascent',fontsize=fs)\n",
    "ax1[2].set_ylabel('Probability',fontsize=fs)\n",
    "ax1[2].set_title('Easily distinguishable bimodal regime',fontsize=fs,color=regime_colors[0])\n",
    "\n",
    "\n",
    "\n",
    "xvals = np.arange(mx[0])\n",
    "Pss_arr_2 = [models[k].get_Pss(*decode_fun_2d[k](x2_2d,y2_2d,K_avg,beta,gamma),[mx[0],1]) for  k in range(nmod)]\n",
    "for k in range(3):\n",
    "    ax1[3].plot(xvals,Pss_arr_2[k],linewidth=2,color=model_colors[k])\n",
    "ax1[3].set_xlabel('# nascent',fontsize=fs)\n",
    "ax1[3].set_ylabel('Probability',fontsize=fs)\n",
    "ax1[3].set_title('Poorly distinguishable bursty regime',fontsize=fs,color=regime_colors[1])\n",
    "\n",
    "fig1.tight_layout()\n",
    "plt.savefig('figs/fig3c.png',dpi=450)\n",
    "plt.savefig('figs/fig3c.pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0539239",
   "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.9.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}