telegraph_demo.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/pachterlab/GP_2023/blob/main/telegraph_demo.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d939ff06-a918-4aa3-a816-82e0349fb630",
      "metadata": {
        "id": "d939ff06-a918-4aa3-a816-82e0349fb630"
      },
      "source": [
        "# The telegraph process is not a subordinator\n",
        "\n",
        "This notebook uses a modified version of the Gillespie algorithm to simulate a telegraph model of gene switching coupled to a transcription/degradation process. The resulting process dynamics are incompatible with subordinator representations."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "493f6e06-c100-40f8-aa5a-ee69fcd413c5",
      "metadata": {
        "id": "493f6e06-c100-40f8-aa5a-ee69fcd413c5"
      },
      "source": [
        "Import relevant packages."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "58b877b6-1e4d-415c-96b3-af5773350726",
      "metadata": {
        "id": "58b877b6-1e4d-415c-96b3-af5773350726"
      },
      "source": [
        "# Helper functions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "id": "e79e6ca3-12ff-47b0-bcd7-b98aaaeb5663",
      "metadata": {
        "id": "e79e6ca3-12ff-47b0-bcd7-b98aaaeb5663",
        "tags": []
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "from numpy import matlib\n",
        "import scipy.stats\n",
        "\n",
        "import numba\n",
        "import tqdm\n",
        "import multiprocessing\n",
        "import scipy\n",
        "from scipy.fft import ifft, ifft2, ifftn, irfft, irfftn\n",
        "\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "%config InlineBackend.figure_format = 'retina'\n",
        "\n",
        "import time\n",
        "t1 = time.time()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "k8F_XEJ85CF0",
      "metadata": {
        "id": "k8F_XEJ85CF0"
      },
      "source": [
        "## Simulation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "id": "de241355-feff-49e0-977b-7a0eafd916b8",
      "metadata": {
        "id": "de241355-feff-49e0-977b-7a0eafd916b8"
      },
      "outputs": [],
      "source": [
        "@numba.njit\n",
        "def update_rule(population, *args):\n",
        "    '''\n",
        "    Update rule that takes params and \n",
        "    updates the population matrix\n",
        "    '''\n",
        "    k_on, k_off, k, b1 = args\n",
        "    m0, m1, m2 = population    \n",
        "    flux =np.zeros(4)\n",
        "    flux[0], flux[1], flux[2], flux[3] = k_on*(1-m0), k_off*m0, k*m0, b1*m1\n",
        "    return flux\n",
        "    \n",
        "def sample_rxns(prob_arr):\n",
        "    '''\n",
        "    Takes prob_arr and\n",
        "    returns an randomly sampled index according to \n",
        "    the probabilities specificed in prob_arr\n",
        "    '''\n",
        "    num = np.random.rand()\n",
        "    sent = 0\n",
        "    tot = 0.\n",
        "    while tot < num:\n",
        "        tot = tot + prob_arr[sent]\n",
        "        sent = sent + 1\n",
        "    return sent - 1\n",
        "\n",
        "def step(calc_flux, population, t, *args):\n",
        "    '''\n",
        "    Takes flux calculating function, past event, \n",
        "    flux, population, t, args and\n",
        "    returns time to reaction and the reaction that happens\n",
        "    '''\n",
        "    # print(args)\n",
        "    flux = calc_flux( population, *args)[0]\n",
        "    # print(flux)\n",
        "    flux_sum = np.sum(flux)\n",
        "    t = np.random.exponential(1. / flux_sum)\n",
        "    rxn_prob = flux/flux_sum\n",
        "    rxn = sample_rxns(rxn_prob)\n",
        "    \n",
        "    return rxn, t\n",
        "def step_with_queued(calc_flux,population,t,queued_reactions,queued_reaction_times,export_arr,*args):\n",
        "    '''\n",
        "    Takes flux calculating function, past event, \n",
        "    flux, population, t, args and\n",
        "    returns time to reaction and the reaction that happens\n",
        "    '''\n",
        "    # return step(calc_flux,population,t,*args)\n",
        "    if len(queued_reactions)==0:\n",
        "        return step(calc_flux,population,t,*args)\n",
        "    else:\n",
        "        # \n",
        "        population = np.copy(population)\n",
        "        population_orig = np.copy(population)\n",
        "        # queued_reactions = np.copy(queued_reactions)\n",
        "        queued_reaction_times = np.copy(queued_reaction_times)\n",
        "\n",
        "        init_flux = calc_flux( population, *args)[0]\n",
        "        n_rxn = len(init_flux)\n",
        "        fluxes = np.zeros((len(queued_reactions)+1,n_rxn))\n",
        "        fluxes[0] = calc_flux( population, *args)[0]\n",
        "        for q in range(len(queued_reactions)):\n",
        "            population += export_arr[queued_reactions[q]]\n",
        "            fluxes[q+1] = calc_flux( population, *args)[0]\n",
        "\n",
        "        queued_reaction_times = np.concatenate(([t],queued_reaction_times))\n",
        "        flux_sums = fluxes[:-1] * np.diff(queued_reaction_times)[:,None]\n",
        "        flux_sums = np.concatenate((np.zeros(n_rxn)[None,:],flux_sums))\n",
        "        flux_cumsums = np.cumsum(flux_sums,0)\n",
        "        tot_flux_cumsum = flux_cumsums.sum(1)\n",
        "\n",
        "        u = np.random.rand()\n",
        "        flux = np.log(1/u)\n",
        "        \n",
        "        last_ind = np.where(tot_flux_cumsum<flux)[0][-1]\n",
        "        dt = queued_reaction_times[last_ind]-t\n",
        "        flux_orig = np.copy(flux)\n",
        "        flux -= tot_flux_cumsum[last_ind]\n",
        "        dtprime = flux/fluxes[last_ind].sum()\n",
        "        dt += dtprime\n",
        "\n",
        "        flux_sum = fluxes[last_ind]\n",
        "        rxn_prob = flux_sum / flux_sum.sum()\n",
        "        rxn = sample_rxns(rxn_prob)   \n",
        "        return rxn, dt\n",
        "\n",
        "def markovian_simulate(calc_flux, update, population_0, t_arr, tau, \\\n",
        "                       DELAYED_SPECIES_GENERATORS, export_arr,tau_list=None,\\\n",
        "                       return_full=False,*args):\n",
        "    '''\n",
        "    Takes params and\n",
        "    returns matrix of the number of counts for \n",
        "    a species j at time t[i]\n",
        "    '''\n",
        "    if isinstance(tau , list) or isinstance(tau , tuple) :\n",
        "        n_delays = len(tau)\n",
        "    else:\n",
        "        tau = [tau]\n",
        "        n_delays = 1\n",
        "\n",
        "    population_arr = np.zeros((len(t_arr), update.shape[1]))\n",
        "    t = t_arr[0]\n",
        "    population = population_0.copy()\n",
        "    population_arr[0, :] = population\n",
        "    t_list = []\n",
        "    population_list = []\n",
        "    rxn_list = []\n",
        "\n",
        "    t_list.append(t)\n",
        "    population_list.append(population)\n",
        "\n",
        "    # Delay time queue\n",
        "    if tau_list is None:\n",
        "        tau_list = [[]]*n_delays\n",
        "    tau_list_delay_inds = np.asarray(sum([[j]*len(x) for j,x in enumerate(tau_list)],[]))\n",
        "    tau_list_all_delays = np.concatenate(tau_list)\n",
        "    tau_list_sort = np.argsort(tau_list_all_delays).astype(int)\n",
        "\n",
        "    tau_list_delay_inds = list(tau_list_delay_inds[tau_list_sort])\n",
        "    tau_list_all_delays = list(tau_list_all_delays[tau_list_sort])\n",
        "    \n",
        "    while t < t_arr[-1]:\n",
        "        event,dt = step_with_queued(calc_flux,population,t,\\\n",
        "                                    tau_list_delay_inds,tau_list_all_delays,\\\n",
        "                                    export_arr, *args)\n",
        "        \n",
        "\n",
        "        temp_t = t + dt\n",
        "        \n",
        "        # Check if an export event should slot in before t + dt\n",
        "        while (len(tau_list_all_delays) != 0) and (temp_t > tau_list_all_delays[0]):\n",
        "            population = population + export_arr[tau_list_delay_inds[0]]\n",
        "            t = tau_list_all_delays[0]\n",
        "            if t>t_arr[-1]:\n",
        "                break\n",
        "            t_list.append(t)\n",
        "            population_list.append(population)\n",
        "            rxn_list.append(-tau_list_delay_inds[0]-1)\n",
        "            tau_list_all_delays.pop(0) # remove element\n",
        "            tau_list_delay_inds.pop(0)\n",
        "\n",
        "        if len(tau_list_all_delays)!=len(tau_list_delay_inds):\n",
        "            raise ValueError\n",
        "        \n",
        "        # Perform event\n",
        "        population = population + update[event, :]\n",
        "        t = temp_t\n",
        "        t_list.append(t)\n",
        "        population_list.append(population)\n",
        "        rxn_list.append(event)\n",
        "\n",
        "\n",
        "        for j in range(n_delays):\n",
        "            if event in DELAYED_SPECIES_GENERATORS[j]:\n",
        "                tau_list_all_delays.append(t + tau[j])\n",
        "                tau_list_delay_inds.append(j)\n",
        "        tau_list_sort = np.argsort(tau_list_all_delays).astype(int)\n",
        "        tau_list_delay_inds = list(np.asarray(tau_list_delay_inds)[tau_list_sort])\n",
        "        tau_list_all_delays = list(np.asarray(tau_list_all_delays)[tau_list_sort])\n",
        "    \n",
        "    t_only_arr = np.asarray(t_list)\n",
        "    population_list= np.asarray(population_list)\n",
        "    for i in range(len(t_only_arr)):\n",
        "        # print(t_only_arr)\n",
        "        ind = np.searchsorted(t_arr, t_only_arr[i], side = 'right')\n",
        "        # print(ind)\n",
        "        population_arr[ind:] = np.array(population_list[i])\n",
        "    if return_full:\n",
        "        return population_arr,t_only_arr,population_list,rxn_list\n",
        "    else:\n",
        "        return population_arr"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2LaUqhULgb6K",
      "metadata": {
        "id": "2LaUqhULgb6K"
      },
      "source": [
        "## Simulation setup \n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def nondelay_wrapper(N,n,K_val,A_val,beta_val,gamma_val,initcond,number_of_cells=5000,simulation_time=5,ndel=50):\n",
        "\n",
        "    H,A,C,S,k,Hss = sim_setup(N,n,K_val,A_val,beta_val,gamma_val)\n",
        "\n",
        "    delayed_species = []\n",
        "    DELAYED_SPECIES_GENERATORS = [[]]\n",
        "\n",
        "    tau = []\n",
        "\n",
        "    ####\n",
        "    update_arr = S\n",
        "\n",
        "    t_arr = np.linspace(0, simulation_time, ndel,endpoint=False)\n",
        "\n",
        "\n",
        "    export_arr = np.zeros((len(delayed_species),N+n),dtype=int)\n",
        "\n",
        "\n",
        "    samples = np.zeros((number_of_cells, len(t_arr), N+n))\n",
        "\n",
        "\n",
        "    Hss = scipy.linalg.null_space(H.T)\n",
        "    Hss /= Hss.sum()\n",
        "    Hss = Hss.squeeze()\n",
        "\n",
        "    for i in tqdm.tqdm(range(number_of_cells)):\n",
        "        population_0 = np.zeros(N+n,dtype=int)\n",
        "        if initcond[0][0]=='thermalized':\n",
        "            init_state_prob = Hss\n",
        "        elif isinstance(initcond[0][1],int):\n",
        "            init_state_prob = np.zeros(N)\n",
        "            jinit = initcond[0][1]\n",
        "            init_state_prob[jinit] = 1\n",
        "        else:\n",
        "            init_state_prob = initcond[0][1]\n",
        "        if N>1:\n",
        "            population_0[:N] = np.random.multinomial(1,init_state_prob,1)\n",
        "        else:\n",
        "            population_0[:N] = 1\n",
        "        initial_promoter_state = np.where(population_0[:N]==1)[0][0]\n",
        "\n",
        "        for j,condition in enumerate(initcond[1:]):\n",
        "            if isinstance(condition[0],str):\n",
        "                if condition[0]=='deterministic':\n",
        "                    population_0[j+N] = condition[1]\n",
        "                elif condition[0]=='poisson':\n",
        "                    population_0[j+N] = np.random.poisson(condition[1])\n",
        "            else:\n",
        "                if condition[initial_promoter_state][0]=='deterministic':\n",
        "                    population_0[j+N] = condition[initial_promoter_state][1]\n",
        "                elif condition[initial_promoter_state][0]=='poisson':\n",
        "                    population_0[j+N] = np.random.poisson(condition[initial_promoter_state][1])\n",
        "# # print('initcond')\n",
        "            # if condition[0]=='deterministic':\n",
        "            #     population_0[j+N] = condition[1]\n",
        "            # elif condition[0]=='poisson':\n",
        "            #     population_0[j+N] = np.random.poisson(condition[1])\n",
        "        samples[i, :, :],event_t,event_x,_ = markovian_simulate(\n",
        "            propfun_generic, update_arr, population_0, t_arr, \\\n",
        "            tau, DELAYED_SPECIES_GENERATORS, export_arr,[[]],\\\n",
        "            True,(k,K_val,A_val,beta_val,gamma_val,N))\n",
        "    return t_arr,samples,H,A,C,init_state_prob"
      ],
      "metadata": {
        "id": "sHUsYmO4aQ53"
      },
      "id": "sHUsYmO4aQ53",
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "id": "cpFEj7Hpgdl6",
      "metadata": {
        "id": "cpFEj7Hpgdl6"
      },
      "outputs": [],
      "source": [
        "def sim_setup(N,n,K_val,A_val,beta_val,gamma_val):\n",
        "\n",
        "    H = np.zeros((N,N))\n",
        "    for kv in K_val:\n",
        "        H[kv[0],kv[1]] = kv[2]\n",
        "    H -= np.diag(H.sum(1))\n",
        "\n",
        "    A = np.zeros((N,n))\n",
        "    for av in A_val:\n",
        "        A[av[0],av[1]-1] = av[2]\n",
        "\n",
        "    B = np.zeros((n,n))\n",
        "    for bv in beta_val:\n",
        "        B[bv[0]-1,bv[1]-1] = bv[2]\n",
        "    B -= np.diag(B.sum(1))\n",
        "    for gv in gamma_val:\n",
        "        B[gv[0]-1,gv[0]-1] -= gv[1]\n",
        "    \n",
        "\n",
        "    Nspec = N+n\n",
        "    Nrxn = len(K_val) + len(A_val) + len(gamma_val) + len(beta_val)\n",
        "    S_mark = np.zeros((Nrxn,Nspec))\n",
        "    k_mark = np.zeros(Nrxn)\n",
        "\n",
        "    i=0\n",
        "    for kv in K_val:\n",
        "        S_mark[i,kv[0]] = -1\n",
        "        S_mark[i,kv[1]] = 1\n",
        "        k_mark[i] = kv[2]\n",
        "        i+=1\n",
        "\n",
        "    for av in A_val:\n",
        "        S_mark[i,av[1]+N-1] = 1\n",
        "        k_mark[i] = av[2]\n",
        "        i+=1\n",
        "        \n",
        "    for bv in beta_val:\n",
        "        S_mark[i,bv[0]+N-1] = -1\n",
        "        S_mark[i,bv[1]+N-1] = 1\n",
        "        k_mark[i] = bv[2]\n",
        "        i+=1\n",
        "        \n",
        "    for gv in gamma_val:\n",
        "        S_mark[i,gv[0]+N-1] = -1    \n",
        "        k_mark[i] = gv[1]\n",
        "        i+=1\n",
        "\n",
        "    Hss = scipy.linalg.null_space(H.T)\n",
        "    Hss /= Hss.sum()\n",
        "    Hss = Hss.squeeze()\n",
        "\n",
        "    S_mark = S_mark.astype(int)\n",
        "\n",
        "    return H,A,B,S_mark,k_mark,Hss\n",
        "    # print(B)\n",
        "\n",
        "def propfun_generic(x,*args):\n",
        "    # print(args)\n",
        "    k,K_val,A_val,beta_val,gamma_val,N = args[0]\n",
        "    nRxn = len(k)\n",
        "    nCells = x.shape[0]\n",
        "\n",
        "    a = np.zeros((nCells,nRxn),dtype=float)\n",
        "    x = x.T\n",
        "    a = a.T\n",
        "    #######\n",
        "    j = 0 \n",
        "    for i in range(len(K_val)):\n",
        "        a[j] = k[j] * x[K_val[i][0]]\n",
        "        j+=1\n",
        "    for i in range(len(A_val)):\n",
        "        a[j] = k[j] * x[A_val[i][0]]\n",
        "        j+=1\n",
        "    for i in range(len(beta_val)):\n",
        "        a[j] = k[j] * x[beta_val[i][0]+N-1]\n",
        "        j+=1\n",
        "    for i in range(len(gamma_val)):\n",
        "        a[j] = k[j] * x[gamma_val[i][0]+N-1]\n",
        "        j+=1\n",
        "    # print(a)\n",
        "    # print(x)\n",
        "    # raise ValueError\n",
        "    return a.T"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "wyOLxI6GdHtb",
      "metadata": {
        "id": "wyOLxI6GdHtb"
      },
      "source": [
        "## PGF computation for generic non-delayed systems (non-analytical)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "id": "ZXO3nzSgg3k6",
      "metadata": {
        "id": "ZXO3nzSgg3k6"
      },
      "outputs": [],
      "source": [
        "def get_g(mx):\n",
        "    u = []\n",
        "    for i in range(len(mx)):\n",
        "        l = np.arange(mx[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",
        "    return g\n",
        "\n",
        "def compute_coeff(L,V,Vinv,u,j=0):\n",
        "    n_u = u.shape[1]\n",
        "    a = np.asarray([(V@np.diag( Vinv @ u[:,i]))[j] for i in range(n_u)]).T\n",
        "    return a\n",
        "\n",
        "def compute_eigs(C):\n",
        "    L,V = np.linalg.eig(C)\n",
        "    Vinv = np.linalg.inv(V)\n",
        "    return L,V,Vinv\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def pss_wrapper(H,A,C,t,mx,n,N,initcond):\n",
        "    g = np.asarray(get_g(mx)).T\n",
        "    L,V,Vinv = compute_eigs(C)\n",
        "    coeff = np.asarray([compute_coeff(L,V,Vinv,g.T,i) for i in range(n)])\n",
        "    \n",
        "    if initcond[0][0]=='thermalized':\n",
        "        Hfin = scipy.linalg.null_space(H.T)\n",
        "        Hfin /= Hfin.sum()\n",
        "        w = Hfin.squeeze()\n",
        "    elif initcond[0][0]=='deterministic':\n",
        "        w = np.zeros(N)\n",
        "        w[initcond[0][1]] = 1\n",
        "    elif initcond[0][0]=='categorical':\n",
        "        w = initcond[0][1]\n",
        "    else:\n",
        "        raise ValueError('Not implemented')\n",
        "    w = np.asarray(w,dtype=np.complex128)\n",
        "\n",
        "    gf_initcond_prop = np.ones((g.shape[0],N),dtype=np.complex128)\n",
        "\n",
        "    for j,condition in enumerate(initcond[1:]):\n",
        "        if isinstance(condition[0],str): #Identical conditions for all states\n",
        "            if condition[0]=='deterministic':\n",
        "                initcond_gfun = lambda x: (x+1)**condition[1]\n",
        "            elif condition[0]=='poisson':\n",
        "                initcond_gfun = lambda x: np.exp(condition[1]*x)\n",
        "            for i in range(g.shape[0]):\n",
        "                gf_initcond_prop[i,:] *= initcond_gfun(ufun_generic(t,L,coeff[j,:,i]))\n",
        "        elif len(condition)==N: #list of length N\n",
        "            for k in range(N):\n",
        "                if condition[k][0]=='deterministic':\n",
        "                    initcond_gfun = lambda x: (x+1)**condition[k][1]\n",
        "                elif condition[k][0]=='poisson':\n",
        "                    initcond_gfun = lambda x: np.exp(condition[k][1]*x)\n",
        "                for i in range(g.shape[0]):\n",
        "                    gf_initcond_prop[i,k] *= initcond_gfun(ufun_generic(t,L,coeff[j,:,i]))\n",
        "        else: \n",
        "            print(N)\n",
        "            print(len(condition[0]))\n",
        "            raise ValueError\n",
        "    gf_initcond_prop *= w \n",
        "    gf = gfun_numerical(g,t,H,A,N,L,coeff,gf_initcond_prop)\n",
        "\n",
        "    Pss = np.zeros((max(mx),N))\n",
        "    for j in range(N):\n",
        "        Pss[:,j] = np.real(ifft(gf[:,j]))\n",
        "    return Pss.squeeze()\n",
        "\n",
        "def gfun_numerical(g,t,H,A,N,L,coeff,gf_initcond):\n",
        "    gf_ = np.zeros((g.shape[0],N),dtype=np.complex128)\n",
        "    \n",
        "    for i in (range(g.shape[0])):\n",
        "        t0 = 0\n",
        "        y0 = gf_initcond[i]\n",
        "        \n",
        "        Ufun = lambda x: np.asarray([ufun_generic(x,L,coef[:,i]) for coef in coeff])\n",
        "        intfun = lambda t,y: intfun_multi(t,y,H,A,Ufun)\n",
        "        res = scipy.integrate.solve_ivp(intfun,[t,t0],y0)\n",
        "        while res.status == 'running':\n",
        "            res.step()\n",
        "        gf_[i] = res.y[:,-1]\n",
        "    return gf_\n",
        "\n",
        "def ufun_generic(x,L,coeff):\n",
        "    Ufun = (np.exp(L*x)@coeff)\n",
        "    return Ufun\n",
        "\n",
        "def intfun_multi(t,y,H,A,Ufun):\n",
        "    dy = np.dot(H.T,y) + np.dot(A,Ufun(t))*y\n",
        "    return -dy"
      ],
      "metadata": {
        "id": "7LYgd1DZhqUp"
      },
      "id": "7LYgd1DZhqUp",
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "uU7BtKdZc86E",
      "metadata": {
        "id": "uU7BtKdZc86E"
      },
      "source": [
        "# Scenarios"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e4b7a2cd",
      "metadata": {
        "id": "e4b7a2cd"
      },
      "source": [
        "Define parameters."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "k_off = .1\n",
        "k_on = .15\n",
        "\n",
        "N = 2\n",
        "K_val = [[0,1,k_on],\n",
        "         [1,0,k_off]]\n",
        "\n",
        "n = 1\n",
        "A_val =[[1,1,20]]\n",
        "    \n",
        "gamma_val = [[1,3.14]]\n",
        "beta_val = []\n",
        "nCells = 1000"
      ],
      "metadata": {
        "id": "jtt5ns4uaAcC"
      },
      "id": "jtt5ns4uaAcC",
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "oBS8lEPzjEpC",
      "metadata": {
        "id": "oBS8lEPzjEpC"
      },
      "source": [
        "## 2-state, 1-species, homogeneous started at single state"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "id": "-KjuztxhgM60",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-KjuztxhgM60",
        "outputId": "9d6203b7-8ff7-4096-e158-237f771a59f6"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 1000/1000 [00:09<00:00, 103.20it/s]\n"
          ]
        }
      ],
      "source": [
        "initcond = [['deterministic',0],\n",
        "            ['deterministic',0]]\n",
        "t_arr,samples,H,A,C,init_state_prob = nondelay_wrapper(N,n,K_val,A_val,beta_val,gamma_val,initcond,number_of_cells=nCells,simulation_time=5,ndel=200)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### PMF computation for 2-state, 1-species system"
      ],
      "metadata": {
        "id": "Iu-Bo8_wxY3E"
      },
      "id": "Iu-Bo8_wxY3E"
    },
    {
      "cell_type": "code",
      "source": [
        "from scipy.special import gammaln\n",
        "def get_Pss_Huang(my_x, params): #By Dr. John J. Vastola, per Huang (2014)\n",
        "    alpha_1, alpha_2, gamma, k_12, k_21 = params\n",
        "    x_max = int(my_x[-1])\n",
        "    \n",
        "    lambda_0, lambda_1, d, gamma_0, gamma_1 = alpha_2, alpha_1, gamma, k_21, k_12\n",
        "    \n",
        "    \n",
        "    gamma_0 /= d\n",
        "    gamma_1 /= d\n",
        "    lambda_0 /= d\n",
        "    lambda_1 /= d\n",
        "\n",
        "    dlamb = lambda_1-lambda_0\n",
        "    Q = dlamb\n",
        "    beta = 1 + gamma_1 + gamma_0\n",
        "    alf = 1 + gamma_1\n",
        "\n",
        "    Pss = np.zeros(x_max+1)\n",
        "    m_ = np.arange(x_max+1)\n",
        "\n",
        "    gauss_ = np.log(scipy.special.hyp1f1(alf + m_ - 1, beta + m_ - 1, -Q))\n",
        "    log_m_terms = gammaln(alf - 1 + m_) - gammaln(alf - 1) \\\n",
        "        + gammaln(beta - 1) - gammaln(beta - 1 + m_) \\\n",
        "        + m_ * np.log(Q / lambda_0) - gammaln(m_ + 1) + gauss_\n",
        "    \n",
        "    log_n_terms = -lambda_0 + m_*np.log(lambda_0)\n",
        "    for n_ in range(x_max+1):\n",
        "        rang_ = range(n_+1)\n",
        "        Pss[n_] = np.sum(np.exp(log_n_terms[n_] + log_m_terms[rang_] - gammaln(n_-m_[rang_]+1)))\n",
        "    return Pss\n"
      ],
      "metadata": {
        "id": "nHjqdrmQbgqr"
      },
      "id": "nHjqdrmQbgqr",
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# a e s t h e t i c s\n",
        "fs_title = 18\n",
        "fs_axis = 15"
      ],
      "metadata": {
        "id": "gHDv5F48dQ_x"
      },
      "id": "gHDv5F48dQ_x",
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "fig1,ax1=plt.subplots(1,3,figsize=(15,5))\n",
        "\n",
        "X = samples[:,-1,2]\n",
        "x = np.arange(X.max()+2)\n",
        "bins = x-0.5\n",
        "\n",
        "params = [  A_val[0][-1],1e-16, gamma_val[0][-1], K_val[1][-1], K_val[0][-1]]\n",
        "Pss_Huang = get_Pss_Huang(x, params)\n",
        "ax1[0].hist(X,bins=bins,density=True,color = 'lightgray',label='Simulation')\n",
        "ax1[0].plot(x,Pss_Huang,'-',c='firebrick',label='Analytical solution')\n",
        "ax1[0].set_xticks(np.arange(0,16,5))\n",
        "ax1[0].set_xlabel('Copy number',fontsize=fs_axis)\n",
        "ax1[0].set_ylabel('Probability',fontsize=fs_axis)\n",
        "ax1[0].set_title(r'$\\bf{a.}$ Beta-Poisson RNA distribution',fontsize=fs_title)\n",
        "ax1[0].legend(fontsize=fs_axis,frameon=False)\n",
        "\n",
        "\n",
        "dt = t_arr[1]-t_arr[0]\n",
        "Y = np.cumsum(samples[:,:,1]*A_val[0][-1]*dt,1)\n",
        "ax1[1].plot(t_arr,Y[:50,:].T,'k',alpha=0.2)\n",
        "\n",
        "yval = [0,100]\n",
        "t = 2.5\n",
        "h = 0.5\n",
        "ax1[1].plot([t]*2,yval,'-',c='firebrick')\n",
        "ax1[1].plot([t+h]*2,yval,'-',c='orangered')\n",
        "ax1[1].plot([t-h]*2,yval,'-',c='orangered')\n",
        "\n",
        "ax1[1].set_xlabel('Time',fontsize=fs_axis)\n",
        "ax1[1].set_ylabel('Cumulative reaction flux',fontsize=fs_axis)\n",
        "ax1[1].set_title(r'$\\bf{b.}$ Integrated telegraph process',fontsize=fs_title)\n",
        "\n",
        "ti0 = np.argmin(np.abs(t_arr-t))\n",
        "tim1 = np.argmin(np.abs(t_arr-(t-h)))\n",
        "tip1 = np.argmin(np.abs(t_arr-(t+h)))\n",
        "dYm1 = Y[:,ti0]-Y[:,tim1]\n",
        "dYp1 = Y[:,tip1]-Y[:,ti0]\n",
        "\n",
        "jit = np.random.randn(2,nCells)/10\n",
        "ax1[2].scatter(dYm1+jit[0],dYp1+jit[1],5,'k',alpha=0.2)\n",
        "ax1[2].set_xlabel(r'Increase from $t-h$ to $t$',fontsize=fs_axis)\n",
        "ax1[2].set_ylabel(r'Increase from $t$ to $t+h$',fontsize=fs_axis)\n",
        "ax1[2].set_title(r'$\\bf{c.}$ Dependence of increments',fontsize=fs_title)\n",
        "plt.tight_layout()\n",
        "plt.savefig('fig1.png',dpi=450)"
      ],
      "metadata": {
        "id": "fbZFdFEKac4p",
        "outputId": "a7b1a7cd-e437-4146-bff4-0739fb2ae714",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 366
        }
      },
      "id": "fbZFdFEKac4p",
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1080x360 with 3 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "image/png": {
              "width": 1059,
              "height": 349
            },
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "EFTxXLLCd4rm"
      },
      "id": "EFTxXLLCd4rm",
      "execution_count": 11,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "name": "gg220909_telegraph.ipynb",
      "provenance": [],
      "include_colab_link": true
    },
    "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
}