visualize_test_dataset.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f01b4d95",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
    "from matplotlib.lines import Line2D\n",
    "from matplotlib.colors import LogNorm\n",
    "import matplotlib.gridspec as gridspec\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from scipy.stats import linregress, t, gaussian_kde, mannwhitneyu, hmean, combine_pvalues, fisher_exact, ttest_1samp\n",
    "from pybedtools import BedTool, helpers\n",
    "import statsmodels.api as sm\n",
    "from tqdm import tqdm\n",
    "import multiprocessing as mp\n",
    "# helpers.set_tempdir(\n",
    "#         '/home/jupyter/workspaces/neanderthalintrogressionlandscapeinafricanamericans/introgression_african_americans')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2351b3fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_ibdmix_results(filename):\n",
    "    ibdmix = pd.read_csv(filename, sep='\\t', names=['chrom', 'start', 'end', \"LOD\", \"IID\", \n",
    "                                                    \"pop\", \"super_pop\"])\n",
    "    ibdmix['length'] = (ibdmix.end - ibdmix.start)\n",
    "    return ibdmix\n",
    "\n",
    "def load_npz(fn):\n",
    "    arr = np.load(fn, allow_pickle=True)\n",
    "    arr = arr['arr_0']\n",
    "    return arr\n",
    "\n",
    "def sort_individuals(df, K):\n",
    "    \"\"\"\n",
    "    Sort individuals by modal ancestry components and it's intensity\n",
    "    :param df: pd.DataFrame, data frame containing ancestry porportions\n",
    "    :param K: int, K used to run admixture\n",
    "    :return: pd.DataFrame, sorted df\n",
    "    \"\"\"\n",
    "    # get mean ancestry per component for each population\n",
    "    mean_ancestry_pops = df.groupby('population').mean()\n",
    "    # identify modal component for each population, i.e., the component with the highest ancestry proportion\n",
    "    modal_clusters_pops = mean_ancestry_pops.idxmax(axis=1).sort_values()\n",
    "    individual_orders = []\n",
    "    # iterate over all k\n",
    "    for i in df.columns[:-1]:\n",
    "        # get all populations for which the current component is model\n",
    "        pops = modal_clusters_pops[modal_clusters_pops == i].index.values.tolist()\n",
    "        # sort the population by they mean ancestry proportions of the modal component\n",
    "        pops_sorted = mean_ancestry_pops.loc[pops, i].sort_values(ascending=False).index.values\n",
    "        inds = []\n",
    "        # sort the individuals within a population by ancestry proportion\n",
    "        for pop in pops_sorted:\n",
    "            inds.extend(df.loc[df.population == pop, i].sort_values(ascending=False).index.values.tolist())\n",
    "        individual_orders.extend(inds)\n",
    "\n",
    "    df = df.loc[individual_orders, :]\n",
    "    return df\n",
    "\n",
    "\n",
    "def plot_admixture_proportions(df, K):\n",
    "    \"\"\"\n",
    "    Create horizontal bar plot of ADMIXTURE results\n",
    "    :param df: pd.DataFrame, sorted DataFrame with ancestry proportions\n",
    "    :param K: int, K used for admixture run\n",
    "    \"\"\"\n",
    "    colors = [\"red\", \"green\", \"blue\", 'orange']\n",
    "    # pad colors\n",
    "    while K > len(colors):\n",
    "        colors.append((np.random.random(), np.random.random(), np.random.random()))\n",
    "    fig, ax = plt.subplots(figsize=(2, 8))\n",
    "    populations = df.population.values\n",
    "    y_coords = [0]\n",
    "    y_ticks = []\n",
    "    y_labels = []\n",
    "    prev_pop = populations[0]\n",
    "    pop_coord_start = 0\n",
    "    cumulative_padding = 0\n",
    "    padding = 2\n",
    "    for i, pop in enumerate(populations[1:], 1):\n",
    "        if prev_pop != pop:\n",
    "            # get ytick positions and labels\n",
    "            y_ticks.append((pop_coord_start + i + cumulative_padding - 1) / 2)\n",
    "            if prev_pop == 'AA':\n",
    "                y_labels.append('Admixed')\n",
    "            else:\n",
    "                y_labels.append(prev_pop)\n",
    "            prev_pop = pop\n",
    "            # add white space between populations\n",
    "            cumulative_padding += padding\n",
    "            pop_coord_start = i + cumulative_padding\n",
    "        # determine y coords --> add white space between populations\n",
    "        y_coords.append(i + cumulative_padding)\n",
    "    y_ticks.append((pop_coord_start + i + cumulative_padding) / 2)\n",
    "    if prev_pop == 'AA':\n",
    "        y_labels.append('Admixed')\n",
    "    else:\n",
    "        y_labels.append(prev_pop)\n",
    "    prev_k = []\n",
    "    # do plotting\n",
    "    for i, anc in enumerate(df.columns[:-1]):\n",
    "        if i > 0:\n",
    "            ax.barh(y_coords, df.loc[:, anc], left=df.loc[:, prev_k].sum(axis=1), height=1, color=colors[i])\n",
    "        else:\n",
    "            ax.barh(y_coords, df.loc[:, anc], height=1, color=colors[i])\n",
    "        prev_k.append(anc)\n",
    "    # formatting\n",
    "    ax.set_yticks(y_ticks)\n",
    "    ax.set_yticklabels(y_labels, fontsize=10)\n",
    "    ax.set_xticks(np.arange(0, 1.2, 0.2))\n",
    "    ax.invert_yaxis()\n",
    "    ax.set_xlabel(f\"K={K}\", fontsize=12)\n",
    "    ax.set_ylim([len(populations) + cumulative_padding - 0.5, -0.5])\n",
    "    ax.set_xlim([0, 1])\n",
    "    return fig, ax\n",
    "\n",
    "def read_flare(fname_pattern):\n",
    "    dfs = []\n",
    "    for chrom in range(1, 23):\n",
    "        phase_0 = pd.read_csv(fname_pattern.format(chrom=chrom, phase=0),\n",
    "                             header=0, sep='\\t')\n",
    "        phase_0['phase'] = 0\n",
    "        phase_1 = pd.read_csv(fname_pattern.format(chrom=chrom, phase=1),\n",
    "                             header=0, sep='\\t')\n",
    "        phase_1['phase'] = 1\n",
    "        dfs.append(phase_0)\n",
    "        dfs.append(phase_1)\n",
    "    df = pd.concat(dfs)\n",
    "    df['length'] = df.end - df.start\n",
    "    return df\n",
    "\n",
    "\n",
    "def linear_regression(x, y, full_range=False):\n",
    "    reg = linregress(x, y)\n",
    "    if not full_range:\n",
    "        x2 = np.linspace(x.min(), x.max(), 100)\n",
    "    else:\n",
    "        x2 = np.linspace(min([x.min(), y.min()]), \n",
    "                         max([x.max(), y.max()]), 100)\n",
    "    y2 = x2 * reg.slope + reg.intercept\n",
    "#     https://github.com/BMClab/BMC/blob/0c338ecf74798379d724a0f27f399c96b7aecbe3//notebooks/CurveFitting.ipynb\n",
    "    # Confidence interval for the linear fit:\n",
    "    zscore = t.ppf(0.975, x.shape[0] - 2)\n",
    "    s_err = s_err = np.sqrt(np.sum((y - (x * reg.slope + reg.intercept))**2)/(x.shape[0] - 2))\n",
    "    ci = zscore * s_err * np.sqrt(1 / x.shape[0] + (x2 - np.mean(x))**2/np.sum((x2 - np.mean(x))**2))\n",
    "    # Prediction interval for the linear fit:\n",
    "    pi = zscore * s_err * np.sqrt(1 + 1 / x.shape[0] + (x2 - np.mean(x))**2 / np.sum((x2 - np.mean(x))**2))\n",
    "    print(f'Slope: {reg.slope} 95% CI: {reg.slope - reg.stderr * 1.96} - {reg.slope + reg.stderr * 1.96}')\n",
    "    print(f'Intercept: {reg.intercept} 95% CI: {reg.intercept - reg.intercept_stderr * 1.96} - {reg.intercept + reg.intercept_stderr * 1.96}')\n",
    "    \n",
    "    return reg.slope, reg.intercept, reg.rvalue, reg.pvalue, x2, y2, ci, pi\n",
    "    \n",
    "\n",
    "def make_violinplot(amounts, position, ax, color, width=0.5, alpha=1):\n",
    "    parts = ax.violinplot(amounts, showmedians=True, positions=[position], widths=width)\n",
    "    for pc in parts['bodies']:\n",
    "        pc.set_facecolor(color)\n",
    "        pc.set_edgecolor('black')\n",
    "        pc.set_linewidth(0.1)\n",
    "        pc.set_alpha(alpha)\n",
    "    parts['cmedians'].set_color('black')\n",
    "    parts['cmins'].set_color('black')\n",
    "    parts['cmaxes'].set_color('black')\n",
    "    parts['cbars'].set_color('black')\n",
    "    return ax\n",
    "\n",
    "def compare_amounts_predicted_introgressed_sequence_by_populations(df, neanderthal, ax=None, fig=None):\n",
    "    if ax is None or fig is None:\n",
    "        fig, ax = plt.subplots(figsize=(12, 6))\n",
    "    amounts = df.groupby(['super_pop', 'pop', 'IID']).sum().loc[:, 'length'] / 1e6\n",
    "    super_pops = amounts.index.get_level_values(0).unique()\n",
    "    n = 0\n",
    "    xlabels = []\n",
    "    for super_pop, color in zip(['EAS', 'EUR', 'AFR', 'AMR'], \n",
    "                                ['Greens_r', 'Blues_r', 'Reds_r', 'purple']):\n",
    "        if super_pop in super_pops:\n",
    "            c_amounts = amounts.loc[(super_pop, slice(None), slice(None))]\n",
    "        else:\n",
    "            continue\n",
    "        populations = c_amounts.index.get_level_values(0).unique()\n",
    "        if len(populations) > 1:\n",
    "            cmap = plt.colormaps[color]\n",
    "        else:\n",
    "            cmap = color\n",
    "        for i, pop in enumerate(populations, 1):\n",
    "            try:\n",
    "                ax = make_violinplot(c_amounts.loc[pop, :], n, ax, cmap(i * 30))\n",
    "            except TypeError:\n",
    "                ax = make_violinplot(c_amounts.loc[pop, :], n, ax, cmap)\n",
    "            n += 1\n",
    "            if pop == 'AA':\n",
    "                xlabels.append('Admixed')\n",
    "            else:\n",
    "                xlabels.append(pop)\n",
    "    ax.set_xticks(np.arange(0, len(xlabels)))\n",
    "    ax.set_xticklabels(xlabels, rotation=0)\n",
    "    ax.set_ylabel(f'{neanderthal} introgressed per individual (Mb)')\n",
    "    return fig, ax\n",
    "\n",
    "\n",
    "def plot_haplotype_frequencies(df, column, chrom, ax, alpha, color):\n",
    "    c_starts = df.loc[df.chrom == chrom, 'start'].values / 1e6\n",
    "    c_freqs = df.loc[df.chrom == chrom, column].values\n",
    "    c_ends = df.loc[df.chrom == chrom, 'end'].values / 1e6\n",
    "    ax.bar(c_starts, c_freqs, c_ends - c_starts, align='edge', color=color, alpha=alpha)\n",
    "    return ax\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "20aae418",
   "metadata": {},
   "outputs": [],
   "source": [
    "K = 3\n",
    "admixture_proportions = pd.read_csv(f'data/merged_datasets/test_ancestry_proportions-20.9.Q', sep='\\t', \n",
    "                                    header=0, index_col=0)\n",
    "# retain only admixed individuals\n",
    "aa_individuals = pd.read_csv('data/AA_sample_ids.txt', names=['sample'])\n",
    "admixture_proportions = admixture_proportions[np.isin(admixture_proportions.index.values, \n",
    "                                                      aa_individuals['sample'].values)]\n",
    "# add population for downstream compatibility\n",
    "admixture_proportions['population'] = 'AA'\n",
    "admixture_proportions.rename(columns={'WestAfrican': 'AFR', 'NorthernEuropean': 'EUR', 'EastAsian': 'EAS'}, inplace=True)\n",
    "# aggregate Asian ancestries to EAS\n",
    "admixture_proportions.EAS += admixture_proportions.Mayan\n",
    "admixture_proportions.EAS += admixture_proportions.Pima\n",
    "admixture_proportions.AFR += admixture_proportions.EastAfrican\n",
    "admixture_proportions.EUR += admixture_proportions.WesternEuropean\n",
    "admixture_proportions.EUR += admixture_proportions.SouthernEuropean\n",
    "admixture_proportions.EUR += admixture_proportions.Iberian\n",
    "\n",
    "\n",
    "# drop aggregated ancestries\n",
    "admixture_proportions.drop(['Mayan', 'Pima', 'EastAfrican', 'WesternEuropean', 'Iberian', 'SouthernEuropean'],\n",
    "                           axis=1, inplace=True)\n",
    "# sort\n",
    "admixture_proportions.sort_values(['AFR', 'EUR', 'EAS'], inplace=True)\n",
    "admixture_proportions.index = admixture_proportions.index.values.astype(str)\n",
    "# plot\n",
    "# fig, ax = plot_admixture_proportions(admixture_proportions, K)\n",
    "# fig.savefig('visualizations/admixture.pdf', bbox_inches='tight', dpi=600)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c415f3bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "ibdmix_vindija = read_ibdmix_results('results50kb_all_test/ibdmix_Vindija33.19/ibdmix_results_masked_denisovan_combined_50kb_4.0LOD.bed')\n",
    "ibdmix_altai = read_ibdmix_results('results50kb_all_test/ibdmix_Altai/ibdmix_results_masked_denisovan_combined_50kb_4.0LOD.bed')\n",
    "ibdmix_chagyrskaya = read_ibdmix_results('results50kb_all_test/ibdmix_Chagyrskaya/ibdmix_results_masked_denisovan_combined_50kb_4.0LOD.bed')\n",
    "\n",
    "ibdmix_vindija_masked = read_ibdmix_results('results50kb_all_test/ibdmix_Vindija33.19/ibdmix_results_masked_denisovan_combined_50kb_4.0LOD_afr_masked.bed')\n",
    "ibdmix_altai_masked = read_ibdmix_results('results50kb_all_test/ibdmix_Altai/ibdmix_results_masked_denisovan_combined_50kb_4.0LOD_afr_masked.bed')\n",
    "ibdmix_chagyrskaya_masked = read_ibdmix_results('results50kb_all_test/ibdmix_Chagyrskaya/ibdmix_results_masked_denisovan_combined_50kb_4.0LOD_afr_masked.bed')\n",
    "\n",
    "\n",
    "# fig, ax = compare_amounts_predicted_introgressed_sequence_by_populations(ibdmix_vindija, 'Vindija33.19')\n",
    "# fig, ax = compare_amounts_predicted_introgressed_sequence_by_populations(ibdmix_vindija_masked, 'Vindija33.19')\n",
    "\n",
    "# fig, ax = compare_amounts_predicted_introgressed_sequence_by_populations(ibdmix_altai, 'Altai')\n",
    "# fig, ax = compare_amounts_predicted_introgressed_sequence_by_populations(ibdmix_chagyrskaya, 'Chagyrskaya')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "2467e32b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_expected_introgression(admixture_proportions, ibdmix):\n",
    "    # calculate introgressed amount per individual\n",
    "    amounts = ibdmix.groupby('IID').sum().loc[:, ['length']] / 1e6\n",
    "    # join with admixture proportions\n",
    "    amounts = amounts.join(admixture_proportions)\n",
    "    # select admixed individuals only\n",
    "    amounts = amounts[amounts.population == 'AA']\n",
    "    super_pop_indv_mapping = ibdmix.drop_duplicates(\"IID\").loc[:, [\"IID\", 'super_pop']].set_index('IID')\n",
    "    # groupby individual\n",
    "    amount_introgression_per_indv = ibdmix.loc[:, ['IID', 'length']].groupby('IID').sum() / 1e6\n",
    "    # calculate mean per continental population\n",
    "    amount_introgression_superpop_per_indv = super_pop_indv_mapping.join(amount_introgression_per_indv)\n",
    "    mean_introgression_per_superpop = amount_introgression_superpop_per_indv.groupby('super_pop').mean()\n",
    "    if not 'AFR' in mean_introgression_per_superpop.index:\n",
    "        mean_introgression_per_superpop.loc['AFR', 'length'] = 0.0\n",
    "    if not 'EUR' in mean_introgression_per_superpop.index:\n",
    "        mean_introgression_per_superpop.loc['EUR', 'length'] = 0.0\n",
    "    if not 'EAS' in mean_introgression_per_superpop.index:\n",
    "        mean_introgression_per_superpop.loc['EAS', 'length'] = 0.0\n",
    "    amounts['expected_introgression'] = (amounts.AFR * \n",
    "                                         mean_introgression_per_superpop.loc['AFR', 'length'] + \n",
    "                                         amounts.EUR * \n",
    "                                         mean_introgression_per_superpop.loc['EUR', 'length'] +\n",
    "                                         amounts.EAS * \n",
    "                                         mean_introgression_per_superpop.loc['EAS', 'length'])\n",
    "        \n",
    "    return amounts\n",
    "\n",
    "def plot_observed_vs_expected_amounts(amounts, color_scatter='lightblue', color_reg='blue', ax=None):\n",
    "    # do regression\n",
    "    (slope, intercept, rval, pval, x_model, y_model, \n",
    "     ci, pi) = linear_regression(amounts.expected_introgression, amounts['length'], full_range=True)\n",
    "    if ax is None:\n",
    "        fig, ax = plt.subplots()\n",
    "    amounts =  amounts.copy()\n",
    "    amounts.reset_index(inplace=True)\n",
    "    xy = np.vstack([amounts.expected_introgression, amounts['length']])\n",
    "    z = gaussian_kde(xy)(xy)\n",
    "    # Sort the points by density, so that the densest points are plotted last\n",
    "    idx = z.argsort()\n",
    "    x, y, z = amounts.loc[idx, 'expected_introgression'], amounts.loc[idx, 'length'], z[idx]\n",
    "#     cax = ax.scatter(x, y, s=2, cmap=color_scatter, \n",
    "#                      norm=LogNorm(vmin=z.min(), vmax=z.max()))\n",
    "    ax.scatter(amounts.expected_introgression.values, amounts['length'].values, c=color_scatter, s=2)\n",
    "    ax.plot(x_model, y_model, ls='--', color=color_reg,\n",
    "            label=f'a={np.round(slope, 2)}; c={np.round(intercept, 2)}')\n",
    "#     ax.fill_between(x_model, y_model + ci, y_model - ci, color=color_reg, alpha=0.4)\n",
    "    if pval <= 1e-6:\n",
    "        ax.annotate(r'$p\\leq10^{-6}$; ' + r'$r$' + \n",
    "                    '={:.2f}'.format(rval), (1, 1), (0.05, 0.93), \n",
    "                   xycoords='axes fraction', fontsize=7)\n",
    "    else:\n",
    "        ax.annotate('p={:.2e}; '.format(pval) + r'$r$' + \n",
    "                    '={:.2f}'.format(rval), (1, 1), (0.05, 0.93), \n",
    "                       xycoords='axes fraction', fontsize=7)\n",
    "    ax.plot(x_model, x_model, ls='--', c='black', label='a=1, c=0')\n",
    "    ax.legend(bbox_to_anchor=(0.5, -.34), loc='center', ncol=2, fontsize=7, labelspacing=0.01,\n",
    "              handlelength=1.4, columnspacing=0.5, handletextpad=0.4)\n",
    "    # ax.plot(x_model, y_model + pi, ls=':', color='blue')\n",
    "    # ax.plot(x_model, y_model - pi, ls=':', color='blue')\n",
    "#     ax.set_xlabel('Exp. introgression (Mb)', fontsize=8)\n",
    "#     ax.set_ylabel('Obs. introgression per individual (Mb)', fontsize=10)\n",
    "    min_lim = max([min([amounts.expected_introgression.min(), amounts['length'].min()]) - 1, 0])\n",
    "    max_lim = max([amounts.expected_introgression.max(), amounts['length'].max()]) + 1\n",
    "    ax.set_xlim([min_lim, max_lim])\n",
    "    ax.set_ylim([min_lim, max_lim])\n",
    "    ax.set_aspect('equal')\n",
    "    \n",
    "    return ax, cax\n",
    "\n",
    "def plot_hist_of_ratios_of_obs_vs_exp_amounts(df, color, simulation_ratios, ax=None,\n",
    "                                              bins=np.linspace(-.2, .5, 200), \n",
    "                                              color_sim='gray'):\n",
    "    if ax is None:\n",
    "        fig, ax = plt.subplots()\n",
    "    \n",
    "    for i in range(simulation_ratios.shape[0]):\n",
    "        if simulation_ratios[i].shape[0] < 900:\n",
    "#             print(i)\n",
    "            continue\n",
    "        ax.hist(np.log10(simulation_ratios[i].astype(float)), bins=bins, histtype='step', color=color_sim,\n",
    "                weights=np.repeat(1 / simulation_ratios[i].shape[0], simulation_ratios[i].shape[0]), \n",
    "                alpha=0.1)\n",
    "    ax.hist(np.log10(df['length'] / df['expected_introgression']), bins=bins, histtype='step', color=color,\n",
    "            weights=np.repeat(1 / df.shape[0], df.shape[0]), alpha=1)\n",
    "    ax.axvline(0, ls='--', color='black')\n",
    "#     test = ttest_1samp(np.log(df['length'] / df['expected_introgression']), 0)\n",
    "#     if test.pvalue <= 1e-6:\n",
    "#         ax.annotate('P' r'$\\leq$' + '{:.0e}'.format(1e-6), (1, 1), (0.8, 0.95), \n",
    "#                     xycoords='axes fraction')\n",
    "#     else:\n",
    "#         ax.annotate('P={:.3e}'.format(test.pvalue), (1, 1), (0.8, 0.95), \n",
    "#                    xycoords='axes fraction')\n",
    "    ax.axvline(0, ls='--', color='black')\n",
    "    ax.set_xlabel(r'$log10(\\frac{Observed\\ introgression\\ in\\ Mb}{Expected\\ introgression\\ in\\ Mb})$')\n",
    "    return ax\n",
    "\n",
    "def plot_hist_of_diff_of_obs_vs_exp_amounts(df, color, simulation_diffs, ax=None,\n",
    "                                            bins=np.linspace(-.2, .5, 200), \n",
    "                                            color_sim='gray', data='unfiltered'):\n",
    "    if ax is None:\n",
    "        fig, ax = plt.subplots()\n",
    "    \n",
    "    for i in range(simulation_diffs.shape[0]):\n",
    "        # divide diff by simulated genome size\n",
    "        ax.hist(simulation_diffs[i] / (903043000 / 1e6) * 100, bins=bins, histtype='step', color=color_sim,\n",
    "                weights=np.repeat(1 / simulation_diffs[i].shape[0], simulation_diffs[i].shape[0]), \n",
    "                alpha=0.4)\n",
    "    # divide diff by autosomal genome size\n",
    "    ax.hist((df['length'] - df['expected_introgression']) / (2875001522 / 1e6) * 100, bins=bins, \n",
    "            histtype='step', color=color,\n",
    "            weights=np.repeat(1 / df.shape[0], df.shape[0]), alpha=1)\n",
    "    ax.axvline(0, ls='--', color='black')\n",
    "    if data == 'unfiltered':\n",
    "        ax.set_xlabel('Unfiltered obs. - exp.\\nNeanderthal admixture fraction (%)', fontsize=7)\n",
    "    elif data == 'afr':\n",
    "        ax.set_xlabel('African masked obs. - exp.\\nNeanderthal admixture fraction (%)', fontsize=7)\n",
    "#     test = ttest_1samp(np.log(df['length'] / df['expected_introgression']), 0)\n",
    "#     if test.pvalue <= 1e-6:\n",
    "#         ax.annotate('P' r'$\\leq$' + '{:.0e}'.format(1e-6), (1, 1), (0.8, 0.95), \n",
    "#                     xycoords='axes fraction')\n",
    "#     else:\n",
    "#         ax.annotate('P={:.3e}'.format(test.pvalue), (1, 1), (0.8, 0.95), \n",
    "#                    xycoords='axes fraction')\n",
    "    ax.axvline(0, ls='--', color='black')\n",
    "    return ax\n",
    "\n",
    "def load_simulations(prefix):\n",
    "    ratios = load_npz(f'{prefix}_ratios.npz')\n",
    "    ratios_short = load_npz(f'{prefix}_ratios_short_segments.npz')\n",
    "    ratios_medium = load_npz(f'{prefix}_ratios_medium_segments.npz')\n",
    "    ratios_long = load_npz(f'{prefix}_ratios_long_segments.npz')\n",
    "\n",
    "    differences = load_npz(f'{prefix}_differences.npz')\n",
    "    differences_short = load_npz(f'{prefix}_differences_short_segments.npz')\n",
    "    differences_medium = load_npz(f'{prefix}_differences_medium_segments.npz')\n",
    "    differences_long = load_npz(f'{prefix}_differences_long_segments.npz')\n",
    "\n",
    "    slopes = load_npz(f'{prefix}_slopes.npz')\n",
    "    intercepts = load_npz(f'{prefix}_intercepts.npz')\n",
    "    try:\n",
    "        lengths = load_npz(f'{prefix}_segment_lengths.npz')\n",
    "        lengths = np.concatenate(lengths) / 1000\n",
    "    except:\n",
    "        print(f\"couldn't load {prefix}_segment_lengths.npz\")\n",
    "        lengths = []\n",
    "    try:\n",
    "        lods = load_npz(f'{prefix}_segment_lods.npz')\n",
    "        lods = np.concatenate(lods)\n",
    "    except:\n",
    "        print(f\"couldn't load {prefix}_segment_lods.npz\")\n",
    "        lods = []\n",
    "    return (ratios, ratios_short, ratios_medium, ratios_long, differences, differences_short, \n",
    "            differences_medium, differences_long, slopes, intercepts, lengths, lods) \n",
    "\n",
    "# def plot_scatter_and_simulated_hist(amounts, simulations_simple, simulations_full,\n",
    "def plot_scatter_and_simulated_hist(amounts, simulations,\n",
    "                                    histrange=(-.5, .5), color_scatter='royalblue', color_reg='blue',\n",
    "                                    color_sim='blue', plot_difference=False):\n",
    "    fig = plt.figure(figsize=(10, 6))\n",
    "    gs_outer = fig.add_gridspec(1, 2, width_ratios=[5, 6], wspace=0.25)\n",
    "    gs2 = gridspec.GridSpecFromSubplotSpec(44, 20, subplot_spec = gs_outer[1], wspace=0.15)\n",
    "\n",
    "    ax = fig.add_subplot(gs_outer[0])\n",
    "    \n",
    "    ax1 = fig.add_subplot(gs2[8:36, 3:])\n",
    "#     ax2 = fig.add_subplot(gs2[4:21, 1], sharey=ax1)\n",
    "#     plt.subplots_adjust(wspace=1.5)\n",
    "    bins = np.linspace(histrange[0], histrange[1], 200)\n",
    "    ax, cax = plot_observed_vs_expected_amounts(amounts, ax=ax, color_scatter=color_scatter, \n",
    "                                           color_reg=color_reg)\n",
    "    divider = make_axes_locatable(ax)\n",
    "    c_ax = divider.append_axes('right', size='5%', pad=0.05)\n",
    "    cbar = fig.colorbar(cax, cax=c_ax, ax=ax)\n",
    "    cbar.set_label('Density')\n",
    "    if plot_difference:\n",
    "        ax1 = plot_hist_of_diff_of_obs_vs_exp_amounts(amounts, color_sim, simulations,\n",
    "                                                        ax=ax1, bins=bins)\n",
    "#         ax2 = plot_hist_of_diff_of_obs_vs_exp_amounts(amounts, color_sim, simulations_full,\n",
    "#                                                         ax=ax2, bins=bins)\n",
    "    else:\n",
    "        ax1 = plot_hist_of_ratios_of_obs_vs_exp_amounts(amounts, color_sim, simulations,\n",
    "                                                        ax=ax1, bins=bins)\n",
    "#         ax2 = plot_hist_of_ratios_of_obs_vs_exp_amounts(amounts, color_sim, simulations_full,\n",
    "#                                                         ax=ax2, bins=bins)\n",
    "#     plt.setp(ax2.get_yticklabels(), visible=False)\n",
    "    # ax[2].set_xticks([])\n",
    "\n",
    "    handles = [Line2D([0], [0], ls='-', color='gray', label='Simulations'),\n",
    "               Line2D([0], [0], ls='-', color=color_sim, label='Admixed individuals')]\n",
    "    ax1.legend(handles=handles, bbox_to_anchor=(0.5, -.2), ncol=2, loc='upper center')\n",
    "    ax1.set_ylabel('Density')\n",
    "\n",
    "\n",
    "\n",
    "#     ax1.set_title(\"Model I\", fontsize=10)\n",
    "#     ax2.set_title(\"Model II\", fontsize=10)\n",
    "\n",
    "    ax.annotate(\"A\", (1, 1), (-.25, 0.95), xycoords='axes fraction', fontsize=14, fontweight='bold')\n",
    "    ax1.annotate(\"B\", (1, 1), (-.2, 0.95), xycoords='axes fraction', fontsize=14, fontweight='bold')\n",
    "    return fig, ax, ax1\n",
    "\n",
    "\n",
    "# amounts_vindija = calculate_expected_introgression(admixture_proportions, ibdmix_vindija)\n",
    "# amounts_altai = calculate_expected_introgression(admixture_proportions, ibdmix_altai)\n",
    "# amounts_chagyrskaya = calculate_expected_introgression(admixture_proportions, ibdmix_chagyrskaya)\n",
    "\n",
    "# (simulations_ratios, simulations_ratios_short, \n",
    "#  simulations_ratios_medium, simulations_ratios_long, \n",
    "#  simulations_differences, simulations_differences_short, \n",
    "#  simulations_differences_medium, \n",
    "#  simulations_differences_long, simulations_slopes, \n",
    "#  simulations_intercepts, simulations_lengths, \n",
    "#  simulations_lods) = load_simulations('simulations')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f76f4096",
   "metadata": {},
   "outputs": [],
   "source": [
    "amounts_vindija_masked = calculate_expected_introgression(admixture_proportions, ibdmix_vindija_masked)\n",
    "amounts_altai_masked = calculate_expected_introgression(admixture_proportions, ibdmix_altai_masked)\n",
    "\n",
    "amounts_chagyrskaya_masked = calculate_expected_introgression(admixture_proportions, ibdmix_chagyrskaya_masked)\n",
    "\n",
    "\n",
    "(simulations_afr_masked_ratios, simulations_afr_masked_ratios_short, \n",
    " simulations_afr_masked_ratios_medium, simulations_afr_masked_ratios_long, \n",
    " simulations_afr_masked_differences, simulations_afr_masked_differences_short, \n",
    " simulations_afr_masked_differences_medium, \n",
    " simulations_afr_masked_differences_long, simulations_afr_masked_slopes, \n",
    " simulations_afr_masked_intercepts, simulations_afr_masked_lengths, \n",
    " simulations_afr_masked_lods) = load_simulations('simulations_afr_masked')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "c8bfccfb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Slope: 1.2178844600248224 95% CI: 1.0834277681467288 - 1.352341151902916\n",
      "Intercept: -4.088669623430594 95% CI: -6.848989166115025 - -1.3283500807461617\n",
      "Slope: 1.0985016907539031 95% CI: 0.967833841499297 - 1.2291695400085094\n",
      "Intercept: -0.7639722259838364 95% CI: -1.3351648196090928 - -0.19277963235857998\n",
      "Slope: 1.2636391378851162 95% CI: 1.092209538741176 - 1.4350687370290562\n",
      "Intercept: -5.183068422052859 95% CI: -9.389110005501422 - -0.9770268386042966\n",
      "Slope: 1.1631260035706013 95% CI: 1.0285954561069799 - 1.2976565510342226\n",
      "Intercept: -0.8058268826801163 95% CI: -1.3089086471839058 - -0.30274511817632677\n",
      "Slope: 1.242606373545491 95% CI: 1.1166769072210505 - 1.3685358398699317\n",
      "Intercept: -4.20433651566265 95% CI: -6.608426812537571 - -1.8002462187877288\n",
      "Slope: 1.0892312592158075 95% CI: 0.9557928615379996 - 1.2226696568936155\n",
      "Intercept: -0.6455702821046732 95% CI: -1.2012591244587307 - -0.08988143975061569\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x1100 with 12 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_colorbar(ax, cax, fig):\n",
    "    divider = make_axes_locatable(ax)\n",
    "    c_ax = divider.append_axes('right', size='5%', pad=0.05)\n",
    "    cbar = fig.colorbar(cax, cax=c_ax, ax=ax)\n",
    "    cbar.set_label('Density')\n",
    "\n",
    "fig= plt.figure(figsize=(8, 11))\n",
    "\n",
    "gs_outer = fig.add_gridspec(4, 1, hspace=0.5, height_ratios=[6, 5, 6, 5])\n",
    "gs0 = gridspec.GridSpecFromSubplotSpec(1, 3, subplot_spec = gs_outer[0], \n",
    "                                       wspace=0.35)\n",
    "gs1 = gridspec.GridSpecFromSubplotSpec(1, 3, subplot_spec = gs_outer[1], \n",
    "                                       wspace=0.35)\n",
    "gs2 = gridspec.GridSpecFromSubplotSpec(1, 3, subplot_spec = gs_outer[2], \n",
    "                                       wspace=0.35)\n",
    "gs3 = gridspec.GridSpecFromSubplotSpec(1, 3, subplot_spec = gs_outer[3], \n",
    "                                       wspace=0.35)\n",
    "\n",
    "ax0 = fig.add_subplot(gs0[0])\n",
    "ax1 = fig.add_subplot(gs0[1])\n",
    "ax2 = fig.add_subplot(gs0[2])\n",
    "ax3 = fig.add_subplot(gs1[0])\n",
    "ax4 = fig.add_subplot(gs1[1], sharey=ax3)\n",
    "ax5 = fig.add_subplot(gs1[2], sharey=ax3)\n",
    "\n",
    "ax6 = fig.add_subplot(gs2[0])\n",
    "ax7 = fig.add_subplot(gs2[1])\n",
    "ax8 = fig.add_subplot(gs2[2])\n",
    "ax9 = fig.add_subplot(gs3[0])\n",
    "ax10 = fig.add_subplot(gs3[1], sharey=ax9)\n",
    "ax11 = fig.add_subplot(gs3[2], sharey=ax9)\n",
    "# ax12 = fig.add_subplot(gs0[3])\n",
    "# ax13 = fig.add_subplot(gs2[3])\n",
    "\n",
    "\n",
    "handles_full = [Line2D([0], [0], ls='-', color='gray', label='Simulations'),\n",
    "                Line2D([0], [0], ls='-', color='purple', label='Admixed')]\n",
    "handles_masked = [Line2D([0], [0], ls='-', color='gray', label='Simulations'),\n",
    "                Line2D([0], [0], ls='-', color='red', label='Admixed')]\n",
    "\n",
    "ax0, cax = plot_observed_vs_expected_amounts(amounts_vindija, ax=ax0, color_scatter='purple', \n",
    "                                            color_reg='mediumvioletred')\n",
    "ax0.set_ylabel('Unfiltered obs.\\nintrogression (Mb)', fontsize=8)\n",
    "ax0.set_xlabel('Unfiltered exp.\\nintrogression (Mb)', fontsize=8, labelpad=1)\n",
    "\n",
    "ax0.set_title('Vindija33.19', fontsize=9)\n",
    "ax6, cax3 = plot_observed_vs_expected_amounts(amounts_vindija_masked, ax=ax6, color_scatter='red', \n",
    "                                            color_reg='red')\n",
    "ax6.set_ylabel('African masked obs.\\nintrogression (Mb)', fontsize=8)\n",
    "ax6.set_xlabel('African masked exo.\\nintrogression (Mb)', fontsize=8, labelpad=1)\n",
    "\n",
    "ax1, cax1 = plot_observed_vs_expected_amounts(amounts_altai, ax=ax1, color_scatter='purple', \n",
    "                                            color_reg='mediumvioletred')\n",
    "ax1.set_title('Altai', fontsize=9)\n",
    "ax1.set_xlabel('Unfiltered exp.\\nintrogression (Mb)', fontsize=8, labelpad=1)\n",
    "\n",
    "ax7, cax4 = plot_observed_vs_expected_amounts(amounts_altai_masked, ax=ax7, color_scatter='red', \n",
    "                                            color_reg='red')\n",
    "ax7.set_xlabel('African masked exo.\\nintrogression (Mb)', fontsize=8, labelpad=1)\n",
    "\n",
    "ax2, cax2 = plot_observed_vs_expected_amounts(amounts_chagyrskaya, ax=ax2, color_scatter='purple', \n",
    "                                            color_reg='mediumvioletred')\n",
    "ax2.set_title('Chagyrskaya', fontsize=9)\n",
    "ax2.set_xlabel('Unfiltered exp.\\nintrogression (Mb)', fontsize=8, labelpad=1)\n",
    "\n",
    "ax8, cax5 = plot_observed_vs_expected_amounts(amounts_chagyrskaya_masked, ax=ax8, color_scatter='red', \n",
    "                                            color_reg='red')\n",
    "ax8.set_xlabel('African masked exo.\\nintrogression (Mb)', fontsize=8, labelpad=1)\n",
    "\n",
    "# plot_colorbar(ax0, cax, fig)\n",
    "# plot_colorbar(ax1, cax1, fig)\n",
    "# plot_colorbar(ax12, cax2, fig)\n",
    "# plot_colorbar(ax6, cax3, fig)\n",
    "# plot_colorbar(ax7, cax4, fig)\n",
    "# plot_colorbar(ax13, cax5, fig)\n",
    "\n",
    "\n",
    "bins = np.linspace(-.2, 1, 200)\n",
    "\n",
    "ax3 = plot_hist_of_diff_of_obs_vs_exp_amounts(amounts_vindija, 'purple', simulations_differences,\n",
    "                                              ax=ax3, bins=bins)\n",
    "ax3.set_ylabel('Density', fontsize=8)\n",
    "\n",
    "ax3.legend(handles=handles_full, bbox_to_anchor=(0.5, -.42), loc='center', ncol=2, fontsize=7, \n",
    "           labelspacing=0.2, handlelength=1.5, columnspacing=1)\n",
    "ax3.tick_params(axis='x', labelsize=6)\n",
    "ax3.tick_params(axis='y', labelsize=6)\n",
    "\n",
    "ax9 = plot_hist_of_diff_of_obs_vs_exp_amounts(amounts_vindija_masked, 'red', \n",
    "                                              simulations_afr_masked_differences,\n",
    "                                              ax=ax9, bins=bins, data='afr')\n",
    "ax9.legend(handles=handles_masked, bbox_to_anchor=(0.5, -.42), loc='center', ncol=2, fontsize=7, \n",
    "           labelspacing=0.2, handlelength=1.5, columnspacing=1)\n",
    "ax9.set_ylabel('Density', fontsize=8)\n",
    "\n",
    "ax4 = plot_hist_of_diff_of_obs_vs_exp_amounts(amounts_altai, 'purple', simulations_differences,\n",
    "                                              ax=ax4, bins=bins)\n",
    "ax4.legend(handles=handles_full, bbox_to_anchor=(0.5, -.42), loc='center', ncol=2, fontsize=7, \n",
    "           labelspacing=0.2, handlelength=1.5, columnspacing=1)\n",
    "# ax4.set_yticklabels([])\n",
    "ax10 = plot_hist_of_diff_of_obs_vs_exp_amounts(amounts_altai_masked, 'red', \n",
    "                                               simulations_afr_masked_differences,\n",
    "                                              ax=ax10, bins=bins, data='afr')\n",
    "ax10.legend(handles=handles_masked, bbox_to_anchor=(0.5, -.42), loc='center', ncol=2, fontsize=7, \n",
    "           labelspacing=0.2, handlelength=1.5, columnspacing=1)\n",
    "# ax10.set_yticklabels([])\n",
    "\n",
    "ax5 = plot_hist_of_diff_of_obs_vs_exp_amounts(amounts_chagyrskaya, 'purple', simulations_differences,\n",
    "                                              ax=ax5, bins=bins)\n",
    "ax5.legend(handles=handles_full, bbox_to_anchor=(0.5, -.42), loc='center', ncol=2, fontsize=7, \n",
    "           labelspacing=0.2, handlelength=1.5, columnspacing=1)\n",
    "# ax5.set_yticklabels([])\n",
    "\n",
    "ax11 = plot_hist_of_diff_of_obs_vs_exp_amounts(amounts_chagyrskaya_masked, 'red', \n",
    "                                               simulations_afr_masked_differences,\n",
    "                                              ax=ax11, bins=bins, data='afr')\n",
    "ax11.legend(handles=handles_masked, bbox_to_anchor=(0.5, -.42), loc='center', ncol=2, fontsize=7, \n",
    "           labelspacing=0.2, handlelength=1.5, columnspacing=1)\n",
    "# ax11.set_yticklabels([])\n",
    "ax0.tick_params(axis='x', labelsize=7)\n",
    "ax0.tick_params(axis='y', labelsize=7)\n",
    "ax1.tick_params(axis='x', labelsize=7)\n",
    "ax1.tick_params(axis='y', labelsize=7)\n",
    "ax2.tick_params(axis='x', labelsize=7)\n",
    "ax2.tick_params(axis='y', labelsize=7)\n",
    "ax3.tick_params(axis='x', labelsize=7)\n",
    "ax3.tick_params(axis='y', labelsize=7)\n",
    "ax4.tick_params(axis='x', labelsize=7)\n",
    "ax4.tick_params(axis='y', labelsize=7)\n",
    "ax5.tick_params(axis='x', labelsize=7)\n",
    "ax5.tick_params(axis='y', labelsize=7)\n",
    "ax6.tick_params(axis='x', labelsize=7)\n",
    "ax6.tick_params(axis='y', labelsize=7)\n",
    "ax7.tick_params(axis='x', labelsize=7)\n",
    "ax7.tick_params(axis='y', labelsize=7)\n",
    "ax8.tick_params(axis='x', labelsize=7)\n",
    "ax8.tick_params(axis='y', labelsize=7)\n",
    "ax9.tick_params(axis='x', labelsize=7)\n",
    "ax9.tick_params(axis='y', labelsize=7)\n",
    "ax10.tick_params(axis='x', labelsize=7)\n",
    "ax10.tick_params(axis='y', labelsize=7)\n",
    "ax11.tick_params(axis='x', labelsize=7)\n",
    "ax11.tick_params(axis='y', labelsize=7)\n",
    "ax0.annotate(\"A\", (1, 1), (-.3, 0.95), xycoords='axes fraction', fontsize=12, fontweight='bold')\n",
    "ax1.annotate(\"B\", (1, 1), (-.3, 0.95), xycoords='axes fraction', fontsize=12, fontweight='bold')\n",
    "ax2.annotate(\"C\", (1, 1), (-.3, 0.95), xycoords='axes fraction', fontsize=12, fontweight='bold')\n",
    "ax3.annotate(\"D\", (1, 1), (-.3, 0.95), xycoords='axes fraction', fontsize=12, fontweight='bold')\n",
    "ax4.annotate(\"E\", (1, 1), (-.3, 0.95), xycoords='axes fraction', fontsize=12, fontweight='bold')\n",
    "ax5.annotate(\"F\", (1, 1), (-.3, 0.95), xycoords='axes fraction', fontsize=12, fontweight='bold')\n",
    "ax6.annotate(\"G\", (1, 1), (-.3, 0.95), xycoords='axes fraction', fontsize=12, fontweight='bold')\n",
    "ax7.annotate(\"H\", (1, 1), (-.3, 0.95), xycoords='axes fraction', fontsize=12, fontweight='bold')\n",
    "ax8.annotate(\"I\", (1, 1), (-.3, 0.95), xycoords='axes fraction', fontsize=12, fontweight='bold')\n",
    "ax9.annotate(\"J\", (1, 1), (-.3, 0.95), xycoords='axes fraction', fontsize=12, fontweight='bold')\n",
    "ax10.annotate(\"K\", (1, 1), (-.3, 0.95), xycoords='axes fraction', fontsize=12, fontweight='bold')\n",
    "ax11.annotate(\"L\", (1, 1), (-.3, 0.95), xycoords='axes fraction', fontsize=12, fontweight='bold')\n",
    "\n",
    "fig.savefig('visualizations/comp_nea.png', bbox_inches='tight', dpi=600)\n",
    "fig.savefig('visualizations/comp_nea.pdf', bbox_inches='tight', dpi=600)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5bec739",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1206cccf",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:.conda-snakemake]",
   "language": "python",
   "name": "conda-env-.conda-snakemake-py"
  },
  "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.10.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}