17_plot_tasic_homo_zinb_Fig6.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib as mpl\n",
    "import seaborn as sns \n",
    "import warnings\n",
    "import pandas as pd\n",
    "import pickle\n",
    "import anndata  \n",
    "\n",
    "#import plotting constants\n",
    "from readcount_tools import compute_kde, simulate_readcounts\n",
    "from readcount_tools import PAPER_CONTEXT, PAGEWIDTH_IN, SMALL_SIZE,MEDIUM_SIZE,BIGGER_SIZE,LINEWIDTH,POINTSIZE_HIGHLIGHT,POINTSIZE,TICKLENGTH,LEGEND_FONTSIZE,SPINEWIDTH,LETTER_LOC_X,LETTER_LOC_Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean_cutoff=5\n",
    "basepath_simulations = 'data/tasic/simulations/'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load fit results for real data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L6 IT VISp Penk Col27a1 (1049, 11549)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.8/dist-packages/anndata/_core/anndata.py:121: ImplicitModificationWarning: Transforming to str index.\n",
      "  warnings.warn(\"Transforming to str index.\", ImplicitModificationWarning)\n",
      "/usr/local/lib/python3.8/dist-packages/anndata/_core/anndata.py:1830: UserWarning: Variable names are not unique. To make them unique, call `.var_names_make_unique`.\n",
      "  utils.warn_names_duplicates(\"var\")\n"
     ]
    }
   ],
   "source": [
    "filename = f'{basepath_simulations}ZINBfit_single_cluster_meanCutoff_{mean_cutoff}.h5ad'\n",
    "adata_single_cluster_fit_results= anndata.read_h5ad(filename)\n",
    "print(adata_single_cluster_fit_results.uns['clustername'],adata_single_cluster_fit_results.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Load fit results for simulations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from glob import glob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['data/tasic/simulations/ZINBfit_simulation_0_meanCutoff_5.h5ad',\n",
       "       'data/tasic/simulations/ZINBfit_simulation_1_meanCutoff_5.h5ad',\n",
       "       'data/tasic/simulations/ZINBfit_simulation_2_meanCutoff_5.h5ad',\n",
       "       'data/tasic/simulations/ZINBfit_simulation_3_meanCutoff_5.h5ad'],\n",
       "      dtype='<U61')"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#todo adjust to new naming\n",
    "paths_simulation_fit_results = np.sort(glob(f'{basepath_simulations}ZINBfit_simulation_*_meanCutoff_{mean_cutoff}.h5ad'))\n",
    "paths_simulation_fit_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "ads_simulation_fits = []\n",
    "for path in paths_simulation_fit_results:\n",
    "    ads_simulation_fits.append(anndata.read_h5ad(path))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2047196087, 2047196087, 2047196087, 2047196087]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#total UMIs in the simulations\n",
    "[np.sum(ads_simulation_fits[i].obs['ns_observed']) for i in range(len(ads_simulation_fits))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 319.0, 7179.0, 223.0]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#maximum copy numbers in the simulations\n",
    "[ad.uns['amplification_stats']['max'] for ad in ads_simulation_fits]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Load simulations details"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(f'{basepath_simulations}zeta_params_list.pickle','rb') as f:\n",
    "    zeta_params_list = pickle.load(f)\n",
    "with open(f'{basepath_simulations}zeta_params_info_list.pickle','rb') as f:\n",
    "    zeta_params_info_list = pickle.load(f)\n",
    "\n",
    "# which zeta parameter set and which cluster to use in Fig 5 (upper row)\n",
    "paramset_id_single_genes = 2\n",
    "params_single_genes = zeta_params_list[paramset_id_single_genes]\n",
    "infos_single_genes = zeta_params_info_list[paramset_id_single_genes]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'target_mean': 30,\n",
       " 'target_alpha': 50,\n",
       " 'target_ff': 20,\n",
       " 'obs_mean': 29.611,\n",
       " 'obs_ff': 20.07283371044544,\n",
       " 'obs_alpha': 49.68383371044544,\n",
       " 'color': 'tab:orange'}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "infos_single_genes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "adata_single_cluster_fit_results.var.set_index('genes',inplace=True,drop=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Filter warnings and invalid fits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_info(ad,ad_plot,errors_idx, invalid_idx, warnings_idx):\n",
    "\n",
    "    n_errors = sum(errors_idx)\n",
    "    n_invalid = sum(invalid_idx)\n",
    "    n_warnings = sum(warnings_idx)\n",
    "    \n",
    "    print(f'{ad.shape[1]} genes in {ad.uns[\"clustername\"]} cluster')\n",
    "    print(f'Ignoring {n_errors} genes with fitting errors.')\n",
    "    print(f'Ignoring additional {n_invalid} fits invalid with psi>1')\n",
    "    print(f'Ignoring additional {n_warnings} genes with fitting warnings.') \n",
    "    \n",
    "    print(f'{ad_plot.shape[1]} genes remain.')\n",
    "\n",
    "def separate_warnings(s):\n",
    "    s_split=s.replace('[','').replace(']','').replace(\"'\",\"\").split(',')\n",
    "    return s_split\n",
    "\n",
    "def find_overflow_only_warnings(ad):\n",
    "    \n",
    "    print('finding overflow warnings..')\n",
    "    warnings = ad.var['cought_warnings']\n",
    "    overflow_only = np.zeros(warnings.shape).astype(bool)\n",
    "    \n",
    "    for i_gene,s_long in enumerate(warnings.values):\n",
    "        s_split = separate_warnings(s_long)\n",
    "        is_overflow = np.zeros(len(s_split)).astype(bool)\n",
    "        \n",
    "        for i,s in enumerate(s_split):\n",
    "            if 'overflow' in s:\n",
    "                is_overflow[i] = True\n",
    "        \n",
    "\n",
    "        overflow_only[i_gene] = np.all(is_overflow)\n",
    "\n",
    "    ad.var['overflow_only_idx'] = overflow_only\n",
    "\n",
    "    \n",
    "def filter_warnings_errors_invalids(ad,allow_overflows=False,allow_warnings=True):\n",
    "    '''Filters `adata` object containing genewise ZINB fit info, and removes genes with certain fitting errors/-warnings.'''\n",
    "    \n",
    "    #filter errors\n",
    "    errors_idx = ad.var['cought_errors'] != ''\n",
    "    ad_filtered = ad[:,~errors_idx]\n",
    "    \n",
    "    #filter inflations > 1\n",
    "    invalid_idx = ~ad_filtered.var[\"valid_inflation_idx\"]\n",
    "    ad_filtered = ad_filtered[:,~invalid_idx]\n",
    "    \n",
    "    #don't filter warnings at all\n",
    "    if allow_warnings:\n",
    "        filtered_warnings_idx = np.zeros(ad_filtered.shape[1]).astype(bool)\n",
    "    #filter warnings\n",
    "    else:\n",
    "        all_warnings_idx = ad_filtered.var['cought_warnings']!='[]'\n",
    "        if allow_overflows: #allow overflow-only warnings \n",
    "            if not 'only_overflow_idx' in ad_filtered.var.keys():\n",
    "                find_overflow_only_warnings(ad_filtered)\n",
    "            overflow_only_idx = ad_filtered.var['overflow_only_idx']    \n",
    "            #filter all warning sets that are not only overflow warnings\n",
    "            filtered_warnings_idx = np.logical_and(all_warnings_idx,~overflow_only_idx)    \n",
    "        else:\n",
    "            #filter all warnings\n",
    "            filtered_warnings_idx = all_warnings_idx\n",
    "    ad_filtered = ad_filtered[:,~filtered_warnings_idx]\n",
    "        \n",
    "    print_info(ad,ad_filtered,errors_idx, invalid_idx, filtered_warnings_idx)\n",
    "    \n",
    "    return ad_filtered"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finding overflow warnings..\n",
      "11549 genes in L6 IT VISp Penk Col27a1 cluster\n",
      "Ignoring 22 genes with fitting errors.\n",
      "Ignoring additional 2359 fits invalid with psi>1\n",
      "Ignoring additional 2064 genes with fitting warnings.\n",
      "7104 genes remain.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_29711/1405998313.py:35: ImplicitModificationWarning: Trying to modify attribute `.var` of view, initializing view as actual.\n",
      "  ad.var['overflow_only_idx'] = overflow_only\n"
     ]
    }
   ],
   "source": [
    "adata_single_cluster_filtered = filter_warnings_errors_invalids(adata_single_cluster_fit_results,allow_overflows=True,allow_warnings=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "62"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#number of simulated genes>5\n",
    "sum([np.sum(np.array((ad.X.mean(axis=0)>5))) for ad in ads_simulation_fits])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12 genes in simulated_readcounts_fig6_theta10_n100000_a1nan_a2nan_bnan_zmaxnan cluster\n",
      "Ignoring 0 genes with fitting errors.\n",
      "Ignoring additional 0 fits invalid with psi>1\n",
      "Ignoring additional 0 genes with fitting warnings.\n",
      "12 genes remain.\n",
      "16 genes in simulated_readcounts_fig6_theta10_n100000_a10.9600000000000001_a215.1_b91.0_zmax100000.0 cluster\n",
      "Ignoring 0 genes with fitting errors.\n",
      "Ignoring additional 1 fits invalid with psi>1\n",
      "Ignoring additional 0 genes with fitting warnings.\n",
      "15 genes remain.\n",
      "17 genes in simulated_readcounts_fig6_theta10_n100000_a10.36000000000000004_a25.1_b56.0_zmax100000.0 cluster\n",
      "Ignoring 0 genes with fitting errors.\n",
      "Ignoring additional 2 fits invalid with psi>1\n",
      "Ignoring additional 0 genes with fitting warnings.\n",
      "15 genes remain.\n",
      "17 genes in simulated_readcounts_fig6_theta10_n100000_a10.01_a217.6_b71.0_zmax100000.0 cluster\n",
      "Ignoring 0 genes with fitting errors.\n",
      "Ignoring additional 2 fits invalid with psi>1\n",
      "Ignoring additional 0 genes with fitting warnings.\n",
      "15 genes remain.\n"
     ]
    }
   ],
   "source": [
    "ads_simulation_fits=[filter_warnings_errors_invalids(ad) for ad in ads_simulation_fits]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prepare plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clip_for_plotting(ad,low_limit = 10**-1, key='thetas_fit',seed=42):\n",
    "\n",
    "    clipped_idx = ad.var[key] < low_limit\n",
    "    clipped_ad_idx = ad.var.index[clipped_idx]\n",
    "    ad.var[f'{key}_clipped'] = ad.var[key]\n",
    "    ad.var[f'{key}_clipped_jitter'] = ad.var[key]\n",
    "\n",
    "    np.random.seed(seed)\n",
    "    jitter=np.random.normal(loc=low_limit*0.8,scale=low_limit/50,size=sum(clipped_idx))\n",
    "    ad.var.loc[clipped_ad_idx,f'{key}_clipped'] = low_limit\n",
    "    ad.var.loc[clipped_ad_idx,f'{key}_clipped_jitter'] = jitter\n",
    "\n",
    "    return jitter,clipped_idx\n",
    "\n",
    "def highlight_genes_with_clipping(ad,gene_names,ax,\n",
    "                                  xkey='gene_mean_withinCluster',ykey='thetas_fit',\n",
    "                                  low_lim=10**-1,low_lim_clip_factor=0.8):\n",
    "        \n",
    "        xs = ad.var.loc[gene_names][xkey]\n",
    "        ys_unclipped = ad.var.loc[gene_names][ykey]\n",
    "        \n",
    "        ys = []\n",
    "        for y in ys_unclipped:\n",
    "            if y>low_lim:\n",
    "                ys.append(y)\n",
    "            else:\n",
    "                ys.append(low_lim*low_lim_clip_factor)\n",
    "        ax.scatter(xs,ys,c='tab:red',s=POINTSIZE_HIGHLIGHT,zorder=10,rasterized=True)\n",
    "        \n",
    "        for i,gene_name in enumerate(gene_names):\n",
    "            ax.text(xs[i], ys[i]*1.05,gene_name,ha='center',fontsize=LEGEND_FONTSIZE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_single_gene_plot_adatas(ad,percentiles=[],names=[]):\n",
    "\n",
    "    ad_plot = ad[:,names].copy()\n",
    "    means_orig = ad.var.gene_mean_withinCluster.values\n",
    "    means_plot = ad_plot.var.gene_mean_withinCluster.values\n",
    "    ad_plot.var['percentiles']=[percentileofscore(means_orig,m) for m in means_plot]\n",
    "    return ad_plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simulate_matched_zeta(ad_real,zeta_params, zeta_params_info,\n",
    "                          depth=100000,theta=10,scale_n_cells = 100):\n",
    "    '''\n",
    "    Runs zeta simulations for each gene in the provided `ad_real`, such that the simulated\n",
    "    gene has he same mean as the genes in the provided data, and `scale_n_cells` as many cells.\n",
    "    '''\n",
    "    \n",
    "\n",
    "    effective_z_mean = zeta_params_info['obs_mean']\n",
    "    target_readcount_means = ad_real.var['gene_mean_withinCluster']\n",
    "    target_molecule_means = target_readcount_means/effective_z_mean\n",
    "\n",
    "    n_cells = ad_real.shape[0]*scale_n_cells\n",
    "    ps = (target_molecule_means/depth).values\n",
    "\n",
    "    molsim_params = dict(n_cells=n_cells,ps_input=ps,depth=depth,theta_molecules=theta)\n",
    "    tag = 'tag'\n",
    "    print(zeta_params)\n",
    "    ad_sim,params_sim = simulate_readcounts(molsim_params=molsim_params,\n",
    "                                            zeta_params=zeta_params,tag=tag)\n",
    "\n",
    "    ad_sim.uns['plotting_color'] = zeta_params_info['color']\n",
    "    ad_sim.uns['scale_n_cells'] = scale_n_cells\n",
    "    ad_sim.var['percentiles'] = np.nan\n",
    "\n",
    "        \n",
    "    return ad_sim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def single_gene_plot(ad,ad_sim,axes,n_bins=25,\n",
    "                     lineplot_kwargs=dict(linestyle='--',linewidth=LINEWIDTH),\n",
    "                     legend_loc='best',s_zero=POINTSIZE_HIGHLIGHT):\n",
    "   \n",
    "    \n",
    "    n_genes = ad.shape[1]\n",
    "      \n",
    "    for i_gene,ax in enumerate(axes):\n",
    "\n",
    "        gene_counts=ad.X[:,i_gene].A.flatten()\n",
    "        gene_counts_sim = ad_sim.X[:,i_gene].A.flatten()\n",
    "\n",
    "        #take max over sim&real data to create bins that work well for both\n",
    "        maxcount = max(np.concatenate((gene_counts,gene_counts_sim)))              \n",
    "        binwidth = max(1,np.round(maxcount / n_bins)) #binwidth must be 1 at least!\n",
    "        nonzero_bins = np.arange(start=1,stop=maxcount+1,step=binwidth)\n",
    "\n",
    "        plot_gene_histogram(counts=gene_counts,\n",
    "                                  ax=ax,\n",
    "                                  nonzero_bins=nonzero_bins,                                        \n",
    "                                  binwidth=binwidth,\n",
    "                                  color_nonzeros='lightgray')\n",
    "\n",
    "        plot_gene_histogram_as_line(counts=gene_counts_sim,\n",
    "                                   ax=ax,\n",
    "                                   nonzero_bins=nonzero_bins,\n",
    "                                   scale_n_cells = ad_sim.uns['scale_n_cells'],\n",
    "                                   color=ad_sim.uns['plotting_color'],\n",
    "                                   binwidth=binwidth,\n",
    "                                   plot_kwargs=dict(lineplot_kwargs,label='Broken zeta simulation'),\n",
    "                                   s_zero=s_zero)\n",
    "\n",
    "        ax.legend(loc=legend_loc)    \n",
    "        ax.set_title(f'{ad.var[\"genes\"][i_gene]}')\n",
    "        ax.set_xlabel('Read counts')\n",
    "                \n",
    "    sns.despine()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_gene_histogram(counts,ax,nonzero_bins,binwidth,color_nonzeros=None):\n",
    "\n",
    "    n_zeros, heights_nonzero_bins = compute_gene_histogram(counts,nonzero_bins,binwidth)\n",
    "    \n",
    "    label_nonzeros = f'Non-zero bins'\n",
    "    label_zeros = 'Zero-only bin'\n",
    "\n",
    "    ax.bar(x=nonzero_bins[:-1],height=heights_nonzero_bins,width=binwidth,\n",
    "           align='edge',color=color_nonzeros,label=label_nonzeros)\n",
    "    #plot extra zero bin\n",
    "    ax.bar(x=1,height=n_zeros,width=-binwidth,align='edge',color='tab:gray',\n",
    "           label=label_zeros) #x=1 because of negative width!\n",
    "    \n",
    "def compute_gene_histogram(counts,nonzero_bins,binwidth):\n",
    "    \n",
    "    n_zeros = sum(counts==0)\n",
    "    counts_per_nonzero_bin,_ = np.histogram(counts,bins=nonzero_bins)\n",
    "    \n",
    "    avg_counts_per_int_in_nonzero_bin = counts_per_nonzero_bin/binwidth\n",
    "    heights_nonzero_bins = avg_counts_per_int_in_nonzero_bin\n",
    "        \n",
    "    return n_zeros, heights_nonzero_bins\n",
    "\n",
    "def plot_gene_histogram_as_line(counts,ax,nonzero_bins,binwidth,\n",
    "                                scale_n_cells,color='k',plot_kwargs={},\n",
    "                                s_zero=POINTSIZE_HIGHLIGHT):\n",
    "    \n",
    "    n_zeros = sum(counts==0)\n",
    "    counts_per_nonzero_bin,_ = np.histogram(counts,bins=nonzero_bins)\n",
    "    \n",
    "    avg_counts_per_int_in_nonzero_bin = counts_per_nonzero_bin/binwidth\n",
    "    heights_nonzero_bins = avg_counts_per_int_in_nonzero_bin\n",
    "    plotting_bins = [1-binwidth] + list(nonzero_bins)\n",
    "    plotting_bin_widths = np.diff(plotting_bins)\n",
    "    plotting_bincenters = plotting_bins[:-1]+plotting_bin_widths/2\n",
    "    \n",
    "    x = plotting_bincenters\n",
    "    y = np.array([n_zeros] + list(heights_nonzero_bins))/scale_n_cells\n",
    "    \n",
    "    ax.plot(x[1:],y[1:],color=color,**plot_kwargs)\n",
    "    ax.plot(x[0],y[0],color=color,marker='.',linestyle='None', markersize=s_zero)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Figure 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a1': 0.36000000000000004, 'a2': 5.1, 'breakpoint': 56.0, 'z_max': 100000.0, 'constant': False}\n",
      "removing 0 all-zero genes after simulation\n",
      "Broken Zeta amplification with {'a1': 0.36000000000000004, 'a2': 5.1, 'breakpoint': 56.0, 'z_max': 100000.0, 'constant': False}\n",
      "Effectively amplifying with Zs that have mean=30.2, median=25.0, var=637.0, FF=21.1, leading to alpha=51.3\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_29711/4067560376.py:5: ImplicitModificationWarning: Trying to modify attribute `.var` of view, initializing view as actual.\n",
      "  ad.var[f'{key}_clipped'] = ad.var[key]\n",
      "/tmp/ipykernel_29711/553178152.py:173: UserWarning: Tight layout not applied. tight_layout cannot make axes width small enough to accommodate all axes decorations\n",
      "  plt.tight_layout()\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 450x300 with 8 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "example_genes = ['Acbd4','Snx30', 'Luzp1','Papola','Naa50','Srsf3']\n",
    "with mpl.rc_context(PAPER_CONTEXT):\n",
    "    \n",
    "    nrows = 4\n",
    "    ncols = 6\n",
    "    figheight_in = PAGEWIDTH_IN/ncols * nrows\n",
    "    nrows_grid = 8\n",
    "    ncols_grid = 12\n",
    "    fig = plt.figure(figsize=(PAGEWIDTH_IN,figheight_in))\n",
    "    axes = [plt.subplot2grid(shape=(nrows_grid,ncols_grid), loc=(0, col*2),          colspan=2,rowspan=2) for col in range(6)]\n",
    "    ax1 = plt.subplot2grid(shape=(nrows_grid,ncols_grid),   loc=(4, 1), colspan=5,rowspan=4)\n",
    "    ax2 = plt.subplot2grid(shape=(nrows_grid,ncols_grid),   loc=(4, 7), colspan=5, rowspan=4)\n",
    "\n",
    "    low_lim_theta = 10**-1\n",
    "    low_lim_psi = 10**-3\n",
    "    kde=True\n",
    "    n_bins=25\n",
    "    \n",
    "    \n",
    "    #make a separate adata object for the single genes to highlight\n",
    "    ad_single_genes = adata_single_cluster_filtered[:,example_genes].copy()\n",
    "    sort_idx = np.argsort(ad_single_genes.var.gene_mean_withinCluster)\n",
    "    ad_single_genes = ad_single_genes[:,sort_idx]\n",
    "    with warnings.catch_warnings():\n",
    "        warnings.filterwarnings(\"ignore\", category=FutureWarning)\n",
    "        ad_single_genes_simulated = simulate_matched_zeta(ad_single_genes,params_single_genes, infos_single_genes)\n",
    "    \n",
    "    #plot histogram panels for each highlighted gene\n",
    "    single_gene_plot(ad_single_genes,ad_single_genes_simulated,\n",
    "                     axes=axes, n_bins=n_bins,\n",
    "                     lineplot_kwargs=dict(linestyle='--',linewidth=LINEWIDTH))  \n",
    "    for i,ax in enumerate(axes):\n",
    "        if i==0:\n",
    "            ax.set_ylabel('Average number\\nof cells per bin')\n",
    "            ax.get_legend().remove()\n",
    "        elif i==1:\n",
    "            ax.legend(frameon=False,loc=(0,-0.75),ncol=3)\n",
    "        else:\n",
    "            ax.get_legend().remove()\n",
    "        sns.despine(ax=ax)\n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "    \n",
    "    key='theta'    \n",
    "    clip_for_plotting(adata_single_cluster_filtered,key=f'{key}s_fit',low_limit=low_lim_theta)\n",
    "    xdata = adata_single_cluster_filtered.var['gene_mean_withinCluster']\n",
    "    xmin=np.min(xdata)\n",
    "    xmax=np.max(xdata)\n",
    "    ax1.hlines(low_lim_theta,xmin,xmax,colors='tab:gray',linestyles=':',linewidths=LINEWIDTH)\n",
    "    ydata = adata_single_cluster_filtered.var[f'{key}s_fit_clipped_jitter']\n",
    "    if kde:\n",
    "        c = compute_kde(x=xdata,y=ydata, xscale='log',yscale='log')\n",
    "    else:\n",
    "        c = 'tab:gray'\n",
    "    ax1.scatter(xdata,ydata,s=POINTSIZE,linewidth=0,c=c,rasterized=True)    \n",
    "    ax1.set_xscale('log')\n",
    "    ax1.set_yscale('log')\n",
    "    \n",
    "    #lines\n",
    "    for i,ad in enumerate(ads_simulation_fits):\n",
    "        #setup legend \n",
    "        target_alpha=ad.uns[\"infos_zeta_param_set\"][\"target_alpha\"]\n",
    "        target_mean=ad.uns[\"infos_zeta_param_set\"][\"target_mean\"]\n",
    "        legend_label = fr'{target_mean}'\n",
    "        scale_str=str(target_alpha)\n",
    "        scale_str=f'{scale_str}, {(3-len(scale_str))*\"  \"}'\n",
    "        legend_label = f'{scale_str}{legend_label}'\n",
    "        \n",
    "        include_idx = ad.var.gene_mean_withinCluster <= xmax\n",
    "        ad_filtered = ad[:,include_idx].copy()\n",
    "        \n",
    "        clip_for_plotting(ad_filtered,key=f'{key}s_fit',low_limit=low_lim_theta)\n",
    "        ax1.plot(ad_filtered.var.gene_mean_withinCluster,\n",
    "                 ad_filtered.var.thetas_fit_clipped_jitter, \n",
    "                 linestyle='--',c=ad_filtered.uns['clustercolor'],lw=LINEWIDTH,\n",
    "                 label=legend_label)\n",
    "        \n",
    "    #highlight points\n",
    "    highlight_genes_with_clipping(adata_single_cluster_filtered,example_genes,ax1)\n",
    "\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    key='inflation'\n",
    "    \n",
    "    clip_for_plotting(adata_single_cluster_filtered,key=f'{key}s_fit',low_limit=low_lim_psi)\n",
    "    xdata = adata_single_cluster_filtered.var['gene_mean_withinCluster']\n",
    "    xmin=np.min(xdata)\n",
    "    xmax=np.max(xdata)\n",
    "    ax2.hlines(low_lim_psi,xmin,xmax,colors='tab:gray',linestyles=':',linewidths=LINEWIDTH) \n",
    "    ydata = adata_single_cluster_filtered.var[f'{key}s_fit_clipped_jitter']\n",
    "    if kde:\n",
    "        c = compute_kde(x=xdata,y=ydata, xscale='log',yscale='log')\n",
    "    else:\n",
    "        c = 'tab:gray'\n",
    "    ax2.scatter(xdata,ydata,s=POINTSIZE,linewidth=0,c=c,rasterized=True)    \n",
    "    ax2.set_xscale('log')\n",
    "    ax2.set_yscale('log')\n",
    "    \n",
    "    #lines\n",
    "    for i,ad in enumerate(ads_simulation_fits):  \n",
    "        #setup legend\n",
    "        target_alpha=ad.uns[\"infos_zeta_param_set\"][\"target_alpha\"]\n",
    "        target_mean=ad.uns[\"infos_zeta_param_set\"][\"target_mean\"]\n",
    "        legend_label = fr'{target_mean}'\n",
    "        scale_str=str(target_alpha)\n",
    "        scale_str=f'{scale_str}, {(3-len(scale_str))*\"  \"}'\n",
    "        legend_label = f'{scale_str}{legend_label}'\n",
    "        \n",
    "        include_idx = ad.var.gene_mean_withinCluster <= xmax\n",
    "        ad_filtered = ad[:,include_idx].copy()\n",
    "        \n",
    "        clip_for_plotting(ad_filtered,key=f'{key}s_fit',low_limit=low_lim_psi)\n",
    "        ax2.plot(ad_filtered.var.gene_mean_withinCluster,\n",
    "                 ad_filtered.var.inflations_fit_clipped_jitter, \n",
    "                 linestyle='--',c=ad_filtered.uns['clustercolor'],lw=LINEWIDTH,\n",
    "                label=legend_label)\n",
    "\n",
    "        \n",
    "    #highlight points\n",
    "    highlight_genes_with_clipping(adata_single_cluster_filtered,example_genes,ax2,ykey='inflations_fit',low_lim=low_lim_psi)\n",
    "    \n",
    "    leg=ax1.legend(frameon=False,loc=(0.6,0.25),title=r'$\\alpha_Z$,     $E_Z$',fontsize=LEGEND_FONTSIZE,title_fontsize=LEGEND_FONTSIZE)\n",
    "    leg._legend_box.align = \"right\"\n",
    "    leg=ax2.legend(frameon=False,loc=(0.6,0.25),title=r'$\\alpha_Z$,     $E_Z$',fontsize=LEGEND_FONTSIZE,title_fontsize=LEGEND_FONTSIZE)\n",
    "    leg._legend_box.align = \"right\"\n",
    "    \n",
    "    sns.despine(ax=ax1)\n",
    "    sns.despine(ax=ax2)\n",
    "    ax1.minorticks_off()\n",
    "    ax2.minorticks_off()\n",
    "    \n",
    "    ax1.set_rasterization_zorder(0)\n",
    "    ax2.set_rasterization_zorder(0)\n",
    "    ax1.set_yticks(ticks=[10**-1,10**0,10**1],labels=[r'$<10^{-1}$',r'$10^0$',r'$10^1$'])\n",
    "    ax2.set_yticks(ticks=[10**-3,10**-2,10**-1,10**0],labels=[r'$<10^{-3}$',r'$10^{-2}$',r'$10^{-1}$',r'$10^{0}$'])\n",
    "    ax1.set_ylabel('Estimated ZINB\\n' fr'overdispersion $\\hat\\theta$')\n",
    "    ax1.set_xlabel('Mean expression')\n",
    "    ax2.set_ylabel('Estimated ZINB\\n' fr'zero-inflation $\\hat\\psi$',labelpad=-7)\n",
    "    ax2.set_xlabel('Mean expression')\n",
    "    \n",
    "    for i,(ax,xlim,ytick) in enumerate(zip(axes,\n",
    "                            [250,250,500,1000,1000,2000],\n",
    "                            [200,200, 20,   5,   5,   2])):\n",
    "        pad=xlim*0.08\n",
    "        ax.set_xlim(-pad,xlim+pad)\n",
    "        ax.set_xticks([0,xlim])\n",
    "        if i==0:\n",
    "            ax.set_yticks([0,ytick])\n",
    "        else:\n",
    "            ax.set_yticks([ytick])\n",
    "    \n",
    "    letters=['a','b','c','d','e','f',\n",
    "             'h','i']\n",
    "    x_corrections=[0,0,0, 0,0,0,\n",
    "                   0.065,0.065]\n",
    "    up_y=0.16\n",
    "    lo_y=0.05\n",
    "    y_corrections=[up_y,up_y,up_y, up_y,up_y,up_y,\n",
    "                   lo_y,lo_y]\n",
    "    for ax,letter,x_corr,y_corr in zip(axes+[ax1,ax2],letters,x_corrections,y_corrections):\n",
    "        ax.text(LETTER_LOC_X+x_corr,LETTER_LOC_Y+y_corr,letter,transform=ax.transAxes,fontweight='bold')\n",
    "        \n",
    "        for axis in ['bottom','left']:\n",
    "            ax.spines[axis].set_linewidth(SPINEWIDTH)\n",
    "            \n",
    "    plt.tight_layout()\n",
    "    fig.savefig('figures/main_tasic_vs_simulated_readcounts.pdf', dpi=300, format=None,bbox_inches='tight')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  },
  "toc-showtags": false
 },
 "nbformat": 4,
 "nbformat_minor": 4
}