TCGA-reanalysis-reanalysis-no-axes.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "66551ff5",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from skbio.stats.composition import clr\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from skbio.diversity.alpha import shannon\n",
    "from scipy.stats import pearsonr\n",
    "from scipy.stats import mannwhitneyu\n",
    "sns.set(rc={'axes.facecolor':'white', \n",
    "            'figure.facecolor':'white', \n",
    "            'axes.edgecolor':'black', \n",
    "            'grid.color': 'black'\n",
    "            }, \n",
    "       font_scale=2)\n",
    "\n",
    "def rescale(xx):\n",
    "    return(xx/xx.sum(axis=1)[:, np.newaxis] )\n",
    "\n",
    "def add_15_percent_to_top_ylim(ax):\n",
    "    ylim=ax.get_ylim() \n",
    "    ax.set_ylim( ylim[0], ylim[1] + ( ylim[1] - ylim[0] ) * .15)\n",
    "    return(None)\n",
    "hide_axes=True\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a7739a62",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_shannon_plot(df, \n",
    "                      md\n",
    "                     ):\n",
    "    sh_alphas = [shannon(x) for x in df.values]\n",
    "    md['Shannon_diversities'] = sh_alphas\n",
    "\n",
    "    mw = mannwhitneyu( *[md.loc[md.grouping==a].Shannon_diversities\n",
    "                       for a in md.grouping.unique()]\n",
    "                       )\n",
    "\n",
    "    plt.figure(figsize=(12 * .3,7))\n",
    "    if df.shape[0]<=100:\n",
    "        ax=sns.boxplot(x = md.grouping, \n",
    "                    y=md.Shannon_diversities, \n",
    "                    fliersize=0\n",
    "                   )\n",
    "    else:\n",
    "        ax=sns.boxplot(x = md.grouping, \n",
    "                    y=md.Shannon_diversities, \n",
    "                   )\n",
    "        \n",
    "    if df.shape[0]<=100: # make swarmplot if we don't have too many points\n",
    "        sns.swarmplot(x = md.grouping, \n",
    "                      y=md.Shannon_diversities, \n",
    "                      size=5, \n",
    "                      color='black', \n",
    "                      ax=ax\n",
    "                      )\n",
    "\n",
    "    plt.ylabel('Shannon diversity')\n",
    "    plt.xlabel(None)\n",
    "    plt.title('Mann Whitney U p = {:.1e}\\n'.format(mw.pvalue))\n",
    "    plt.xticks(rotation=90)\n",
    "    return(ax)\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e5218160",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_ra_feature_plot(df, \n",
    "                         md, \n",
    "                         val,\n",
    "                         pseudocount=0\n",
    "                         ):\n",
    "\n",
    "    val_ = np.where(df.columns == val)[0][0]\n",
    "    X_ra = rescale(df.values+pseudocount) \n",
    "    md['ra'] = X_ra[:, val_]\n",
    "\n",
    "    try:\n",
    "        mw = mannwhitneyu( *[md.loc[md.grouping==a].ra\n",
    "                           for a in md.grouping.unique()]\n",
    "                           )\n",
    "        pval=mw.pvalue\n",
    "    except:\n",
    "        pval = 1000\n",
    "        \n",
    "    plt.figure(figsize=(12 * .3,7))\n",
    "\n",
    "    if df.shape[0]<=100: \n",
    "        ax = sns.boxplot(x = md.grouping, \n",
    "                         y=X_ra[:,val_], \n",
    "                         fliersize=0\n",
    "                         )\n",
    "    else:\n",
    "        ax = sns.boxplot(x = md.grouping, \n",
    "                         y=X_ra[:,val_], \n",
    "                         )\n",
    "\n",
    "    if df.shape[0]<=100: # make swarmplot if we don't have too many points\n",
    "        sns.swarmplot(x = md.grouping, \n",
    "                      y=X_ra[:,val_], \n",
    "                      size=5, \n",
    "                      color='black', \n",
    "                      ax=ax\n",
    "                      )\n",
    "    plt.ylabel(\"{}'s relative abundance\".format(val.split('g__')[-1]))\n",
    "    plt.xlabel(None)\n",
    "    plt.title( 'Mann Whitney U p = {:.1e}\\n'.format(pval) )\n",
    "    plt.xticks(rotation=90)\n",
    "    return(ax)\n",
    "\n",
    "\n",
    "\n",
    "def make_clr_feature_plot(df, \n",
    "                          md, \n",
    "                          val,\n",
    "                          pseudocount='minimal_value'\n",
    "                          ):\n",
    "\n",
    "    val_ = np.where(df.columns == val)[0][0]\n",
    "    \n",
    "    if pseudocount =='minimal_value':\n",
    "        val_ = np.where(df.columns == val)[0][0]\n",
    "        rsc_df = rescale(df.values)\n",
    "        X_clr = clr(rsc_df + 10**np.floor(np.log10(rsc_df[rsc_df != 0].min())))\n",
    "    elif pseudocount=='one':\n",
    "         X_clr = clr(rescale(1 + df.values)  )\n",
    "    else:\n",
    "        Raise(ValueError('pseudocount must be either `minimal_value` or `one`'))\n",
    "    \n",
    "    md['clre'] = X_clr[:, val_]\n",
    "\n",
    "\n",
    "    mw = mannwhitneyu( *[md.loc[md.grouping==a].clre\n",
    "                       for a in md.grouping.unique()]\n",
    "                       )\n",
    "    plt.figure(figsize=(12 * .3,7))\n",
    "    if df.shape[0]<=100: \n",
    "        ax = sns.boxplot(x = md.grouping, \n",
    "                         y=X_clr[:,val_], \n",
    "                         fliersize=0\n",
    "                         )\n",
    "        \n",
    "    else:\n",
    "        ax = sns.boxplot(x = md.grouping, \n",
    "                         y=X_clr[:,val_], \n",
    "                         )\n",
    "\n",
    "    if df.shape[0]<=100: # make swarmplot if we don't have too many points\n",
    "        sns.swarmplot(x = md.grouping, \n",
    "                      y=X_clr[:,val_], \n",
    "                      size=5, \n",
    "                      color='black', \n",
    "                      ax=ax\n",
    "                      )\n",
    "    plt.ylabel(\"{}'s centered log ratio\".format(val.split('g__')[-1]))\n",
    "    plt.xlabel(None)\n",
    "    plt.title( 'Mann Whitney U p = {:.1e}\\n'.format(mw.pvalue) )\n",
    "    plt.xticks(rotation=90)\n",
    "    return(ax)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9de8018a",
   "metadata": {},
   "source": [
    "## their fig 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a6dc8e76",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('Kraken-TCGA-Raw-Data-17625-Samples.csv', index_col=0)\n",
    "md = pd.read_csv('Metadata-TCGA-All-18116-Samples.csv', index_col=0).loc[df.index]\n",
    "\n",
    "df=df.loc[df.index.isin(md.index)]\n",
    "md=md.loc[md.index.isin(df.index)].loc[df.index]\n",
    "\n",
    "\n",
    "cols = pd.read_csv('Kraken-TCGA-Voom-SNM-Most-Stringent-Filtering-Data.csv', \n",
    "            index_col=0, nrows=1).columns\n",
    "df = df.loc[:, cols[cols.str.contains('contaminant')==False]]\n",
    "df_vsnm=pd.read_csv('Kraken-TCGA-Voom-SNM-Most-Stringent-Filtering-Data.csv', \n",
    "            index_col=0).loc[md.index]\n",
    "\n",
    "md['grouping'] = md.disease_type == 'Adrenocortical Carcinoma'\n",
    "xaxis_name = 'Adrenocortical Carcinoma'\n",
    "\n",
    "save_path = 'tcga_plots-no-axes/Fig-2-Adrenocortical-Carcinoma-Hepandensovirus'\n",
    "val = df.columns[df.columns.str.contains('Hepandensovirus')].values[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "8f7bbb79",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqsAAAGKCAYAAAArAwj/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAK2UlEQVR4nO3dsW5b5xmA4Z+2Bt1AAQ0eKGRwLsCTYSFjxszOzRC+mXjOmKkIZHhSxwLxEIiFVUBoMxaogMo+Xeo4Qkylko+kl/bzjKT56Zjf4BeHv8zFNE3TAACAoHt3fQEAALCJWAUAIEusAgCQJVYBAMja2fTE2dnZODo6Gnt7e2NnZ+MfAwCAj3J+fj5OT0/Ho0ePxu7u7oXnNlbo0dHRODg4uPGLAwCAMcY4PDwcT548ufDYxljd29v79UUPHjy49g/d398fx8fH134987OTptJevv/x59lmffPVF7PPuy2lnfCevfTYSdM27eXk5GQcHBz82p+/tTFW3330/+DBg7FcLj/qAj729czPTpoqe/nTq7PZZi2Xy9nn3abKTrjIXnrspGnb9vKho6d+wQoAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkLWYpmn60BPr9Xrs7+/f9vUAd2yapvHw8dPZ5r16+Xz2eYvFYrZ5AHQcHx+P5XJ54bGd67zoKhaLxdjQw9wRO2kq7WW1WqXn3db7VNoJ79lLj500bdNeLrtJ6hgAAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIWkzTNH3oifV6Pfb392/7eoA7Nk3TePj46WzzXr18Pvu8xWIx2zwAOo6Pj8dyubzw2M51XnQVi8VibOhh7oidNJX2slqt0vNu630q7YT37KXHTpq2aS+X3SR1DAAAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUAgCyxCgBAllgFACBLrAIAkCVWAQDIEqsAAGSJVQAAssQqAABZYhUu8ebN2/Q8APjU7dz1BUDZ/fv3xnc//DTbvG+//nK2WQDwOXBnFQCALLEKAECWWAUAIEusAgCQJVYBAMgSqwAAZIlVAACyxCoAAFliFQCALLEKAECWWAUAIGsxTdP0oSfW6/XY39+/7euBlGmaxsPHT2eb9+rl87FYLGabdxNu4u/8ub2HAFzP8fHxWC6XFx7buc6LrmKxWIwNPcwdsZOrWa1Ws87b9N6X9jL33/m23sO5lXbCe/bSYydN27SXy26SOgYAAECWWAUAIEusAgCQJVYBAMgSqwAAZIlVAACyxCoAAFliFQCALLEKAECWWAUAIEusAgCQJVYBAMgSqwAAZIlVAACyxCoAAFliFQCALLEKAECWWAUAIEusAgCQJVYBAMgSqwAAZIlVAACyxCoAAFliFQCALLEKAECWWAUAIEusAgCQJVYBAMgSqwAAZIlVAACyxCoAAFliFQCALLEKAECWWAUAIEusAgCQJVYBAMgSqwAAZIlVAACyxCoAAFliFQCALLEKAECWWAUAIEusAgCQJVYBAMgSqwAAZIlVAACyxCoAAFliFQCALLEKAECWWAUAIEusAgCQJVYBAMgSqwAAZIlVAACyxCoAAFliFQCALLEKAECWWAUAIEusAgCQJVYBAMgSqwAAZIlVAACyxCoAAFliFQCALLEKAECWWAUAIEusAgCQJVYBAMgSqyFv3rxNzwMAuG07d30BvHf//r3x3Q8/zTbv26+/nG0WAMBdcGcVAIAssQoAQJZYBQAgS6wCAJAlVgEAyBKrAABkiVUAALLEKgAAWWIV2Co38c1svu0NoMs3WAFbZe5vehvDt70BlInVmH//7a8zTvMPMACw3RwDAAAgS6zCLbrsbOQ0TbPPBIBt5xgA3KLLzls+e/ZsrFarK8903hKAT5k7qwAAZIlVAACyxOonbNNZRmcjAYBt4czqJ2zT+UhnIwGAbeHOKmw5d7wB+JS5swpbbu5vdHIHHYASd1YBAMgSq/zf5v642cfXAMAf2XgM4Pz8fIwxxsnJyUf/kPV6feXXvHnzdty/P19Lzz3vpvzyyz9mm7Ver8c/T//+u8f/c/avDz7+R16/3h3f//jzHJc2xhjjm6++mG3WTbrOe7XJer27cd5193LZzOtYr3fH67/8eb55D+e/vjnnvZu5+bn1rD+LedhLj500bcte3vXmu/78rcW04f8xevHixTg4OLjZKwMAgP85PDwcT548ufDYxlg9OzsbR0dHY29vb+zs+D0sAABuxvn5+Tg9PR2PHj0au7sXP+3aGKsAAHDX+oc4AQD4bIlVAACyxCoAAFliFQCArP8CxtqfObdEytwAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 864x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "val_vsnm = df_vsnm.columns[df_vsnm.columns.str.contains('Hepandensovirus')].values[0]\n",
    "plt.figure(figsize=(12,7))\n",
    "# plt.semilogy()\n",
    "inds=df_vsnm[val] < 3.1\n",
    "ax=sns.histplot(x=df_vsnm.loc[inds][val_vsnm].values, \n",
    "             hue = md.loc[inds].grouping.values, \n",
    "             bins=30\n",
    "             )\n",
    "ax.set_yticks(np.linspace(0, 2000, 5))\n",
    "ax.legend_.set_title('Adrenocortical Carcinoma')\n",
    "plt.ylim(0, 2000)\n",
    "if hide_axes:\n",
    "    ax.get_legend().remove()\n",
    "    ax.set(\n",
    "           yticklabels=[], \n",
    "           xticklabels=[])\n",
    "    plt.xlabel(None)\n",
    "    plt.ylabel(None)\n",
    "    plt.title(None)\n",
    "plt.savefig(save_path+'-VSNM.pdf', \n",
    "            dpi=900, \n",
    "            bbox_inches='tight', \n",
    "            format='pdf'\n",
    "            )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4b5c7ab5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 259.2x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 259.2x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 259.2x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 259.2x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 259.2x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "val = df.columns[df.columns.str.contains('Hepandensovirus')].values[0]\n",
    "ax=make_shannon_plot(df, \n",
    "                      md\n",
    "                     )\n",
    "ax.set_xlabel(xaxis_name)\n",
    "# ax.set_ylim(1.5,3.8)\n",
    "add_15_percent_to_top_ylim(ax)\n",
    "if hide_axes:\n",
    "    ax.set(yticklabels=[], \n",
    "           xticklabels=[])\n",
    "    plt.xlabel(None)\n",
    "    plt.ylabel(None)\n",
    "    plt.title(None)\n",
    "plt.savefig(save_path+'-Shannon.pdf', \n",
    "            dpi=900, \n",
    "            bbox_inches='tight', \n",
    "            format='pdf'\n",
    "            )\n",
    "plt.show()\n",
    "\n",
    "ax=make_ra_feature_plot(df, \n",
    "                      md, \n",
    "                      val\n",
    "                      )\n",
    "ax.set_xlabel(xaxis_name)\n",
    "add_15_percent_to_top_ylim(ax)\n",
    "if hide_axes:\n",
    "    ax.set(yticklabels=[], \n",
    "           xticklabels=[] )\n",
    "    plt.xlabel(None)\n",
    "    plt.ylabel(None)\n",
    "    plt.title(None)\n",
    "plt.savefig(save_path+'-RA.pdf', \n",
    "            dpi=900, \n",
    "            bbox_inches='tight', \n",
    "            format='pdf'\n",
    "           )\n",
    "\n",
    "plt.show()\n",
    "\n",
    "\n",
    "ax=make_ra_feature_plot(df, \n",
    "                        md, \n",
    "                        val,\n",
    "                        pseudocount=1\n",
    "                      )\n",
    "ax.set_xlabel(xaxis_name)\n",
    "add_15_percent_to_top_ylim(ax)\n",
    "if hide_axes:\n",
    "    ax.set(yticklabels=[], \n",
    "           xticklabels=[] )\n",
    "    plt.xlabel(None)\n",
    "    plt.ylabel(None)\n",
    "    plt.title(None)\n",
    "plt.savefig(save_path+'-RA-with-pseudocount.pdf', \n",
    "            dpi=900, \n",
    "            bbox_inches='tight', \n",
    "            format='pdf'\n",
    "           )\n",
    "\n",
    "plt.show()\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "ax=make_clr_feature_plot(df, \n",
    "                      md, \n",
    "                      val\n",
    "                      )\n",
    "ax.set_xlabel(xaxis_name)\n",
    "add_15_percent_to_top_ylim(ax)\n",
    "if hide_axes:\n",
    "    ax.set(yticklabels=[], \n",
    "           xticklabels=[])\n",
    "    plt.xlabel(None)\n",
    "    plt.ylabel(None)\n",
    "    plt.title(None)\n",
    "plt.savefig(save_path+'-CLR.pdf', \n",
    "            dpi=900, \n",
    "            bbox_inches='tight', \n",
    "            format='pdf'\n",
    "           )\n",
    "plt.show()\n",
    "\n",
    "ax=make_clr_feature_plot(df, \n",
    "                         md, \n",
    "                         val,\n",
    "                         pseudocount='one'\n",
    "                          )\n",
    "ax.set_xlabel(xaxis_name)\n",
    "add_15_percent_to_top_ylim(ax)\n",
    "if hide_axes:\n",
    "    ax.set(yticklabels=[], \n",
    "           xticklabels=[])\n",
    "    plt.xlabel(None)\n",
    "    plt.ylabel(None)\n",
    "    plt.title(None)\n",
    "plt.savefig(save_path+'-CLR-pseudocount-one.pdf', \n",
    "            dpi=900, \n",
    "            bbox_inches='tight', \n",
    "            format='pdf'\n",
    "           )\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0cd330b",
   "metadata": {},
   "source": [
    "## their fig 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5bafcbfc",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('Kraken-TCGA-Raw-Data-17625-Samples.csv', index_col=0)\n",
    "md = pd.read_csv('Metadata-TCGA-All-18116-Samples.csv', index_col=0).loc[df.index]\n",
    "md=md.loc[md.experimental_strategy=='WGS']\n",
    "md=md.loc[(md.sample_type!='Blood Derived Normal')&\\\n",
    "          (md.disease_type=='Kidney Chromophobe')]\n",
    "\n",
    "df=df.loc[df.index.isin(md.index)]\n",
    "md=md.loc[md.index.isin(df.index)].loc[df.index]\n",
    "\n",
    "md = md.sort_values('sample_type', ascending=False)\n",
    "df=df.loc[md.index]\n",
    "\n",
    "\n",
    "cols=  pd.read_csv('Kraken-TCGA-Voom-SNM-All-Putative-Contaminants-Removed-Data.csv', \n",
    "            index_col=0, nrows=1).columns\n",
    "df = df.loc[:, cols[cols.str.contains('contaminant')==False]]\n",
    "\n",
    "md['grouping'] = md.sample_type\n",
    "save_path = 'tcga_plots-no-axes/Fig-3-KICH-WGS-Thiorhodospira'\n",
    "val = df.columns[df.columns.str.contains('Thiorhodospira')].values[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "257b05d2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_vsnm = pd.read_csv('Kraken-TCGA-Voom-SNM-All-Putative-Contaminants-Removed-Data.csv', \n",
    "                      index_col=0 ).loc[md.index]\n",
    "plt.figure(figsize=(12,7))\n",
    "ax=sns.histplot(x=df_vsnm[val].values, \n",
    "                hue = md.grouping.values, \n",
    "                bins=30\n",
    "                )\n",
    "if hide_axes:\n",
    "    ax.get_legend().remove()\n",
    "    ax.set(\n",
    "           yticklabels=[], \n",
    "           xticklabels=[])\n",
    "    plt.xlabel(None)\n",
    "    plt.ylabel(None)\n",
    "    plt.title(None)\n",
    "plt.savefig(save_path+'-VSNM.pdf', \n",
    "            dpi=900, \n",
    "            bbox_inches='tight', \n",
    "            format='pdf'\n",
    "            )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a097aeb8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 259.2x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/george/opt/anaconda3/envs/pl2/lib/python3.6/site-packages/seaborn/categorical.py:1296: UserWarning: 56.1% of the points cannot be placed; you may want to decrease the size of the markers or use stripplot.\n",
      "  warnings.warn(msg, UserWarning)\n",
      "/Users/george/opt/anaconda3/envs/pl2/lib/python3.6/site-packages/seaborn/categorical.py:1296: UserWarning: 62.0% of the points cannot be placed; you may want to decrease the size of the markers or use stripplot.\n",
      "  warnings.warn(msg, UserWarning)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 259.2x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 259.2x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAANcAAAGKCAYAAACfGtQoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAmYUlEQVR4nO3de3yT9f338XcObdLz+VygpS0nOQkIFCyWYhEVRVCQiQjiNg94O5zznqDzMB33RG7d1OHQOZQxBX7qBBWQcoZyamkLtNCWtkmhlJSej2nSJNfvj9hACFCn/SY0fT8fDx4zVw580vHqlVy5risySZIkEFG3k7t6ACJ3xbiIBGFcRIIwLiJBlNe6or29HdnZ2YiMjIRSec2bEfVaJpMJOp0OY8aMgVqtdryBdA379++XAPAP//BPF3/2799/1YauuUqKjIwEAOzfvx+xsbHXuhlRr1VRUYGUlBRbK1e6ZlydLwVTUlLETEbkJq71tqnLN1MajQZxcXHdPQ9Rj6fVahEfH3/N67m1kEgQxkUkCOMiEoRxEQnCuIgEYVxEgjAuIkEYF5EgjItIEMZFJAjjIhKEcREJwriIBGFcRIIwLiJBGBeRIIyLSBDGRSQI4yIShHERCcK4iARhXESCMC4iQRgXkSCMi0gQxkUkCOMiEoRxEQnCuIgEYVxEgjAuIkEYF5EgjItIEMZFJAjjIhKEcREJwriIBGFcRIIwLiJBGBeRIIyLSBDGRSQI4yIShHERCcK4iARhXESCMC4iQRgXkSCMi0gQxkUkCOMiEoRxEQnCuIgEYVxEgjAuIkEYF5EgjItIEMZFJIjS1QOIZLFY8MUXXyA3Nxe33347pkyZ4uqRqBdx6zXXkiVL8OCDD+LPf/4zbr/9dnzwwQeuHol6EbeNS6/XY/Xq1XbL3nnnHRdNQ72R28Yll8uhVNq/6vX09HTRNNQbdfmeKz4+3hlzOEVBQQFkMpmrx6Beosu4NBoN4uLinDBK95MkCW+88Qb279+PuXPnYtGiRa4eidyIVqu97srHrbcWLlmyBO+++y4AICMjA0ajEU888YSLp6Lewm3fc+n1evz973+3W8YNGuRMbhuXXC6HQqGwW3blBg4ikdw2LpVKhd/97ne2yzKZDMuWLXPhRNTbuPWv8j/+8Y9IS0tDbm4u0tLSMGLECFePRL2IW8cFAKmpqUhNTXX1GNQLue3LQiJXY1xEgjAuIkEYF5Egbh9Xe3s7ioqKYDabXT0K9TJuHdeWLVsQExODQYMGISEhASdOnHD1SNSLuG1cFosFv/71r1FXVwcAKC8vx5IlS1w7FPUqbhtXS0sLzp8/b7esqKjIRdNQb+S2cfn7+zt8eDxjxgzXDEO9klvvobFhwwYsXbrUdoKa1157zdUjUS/i1nGFh4fj448/dvUY1Eu57ctCIldjXESCMC4iQRgXkSCMi0gQxkUkCOMiEoRxEQnCuIgEYVxEgjAuIkEYF5EgjItIEMZFJAjjIhKEcREJwriIBGFcRIIwLiJBGBeRIIyLSBDGRSQI4yIShHERCcK4iARhXESCMC4iQRgXkSCMi0gQxkUkCOMiEoRxEQnCuIgEYVxEgjAuIkEYF5EgjItIEMZFJAjjIhKEcREJwriIBGFcRIIwLiJBGBeRIIyLSBDGRSSIsqsbxMfHO2MOIrfTZVwajQZxcXFOGIWoZ9Fqtddd+fBlIZEgjItIEMZFJAjjIhKkyw0aRN3p5MmT+Ne//oWgoCD86le/QmhoqKtHEoZxkdPk5uYiOTkZBoMBALBmzRqcPHkSKpXKxZOJwZeF5DQff/yxLSwAOHPmDLZv3+7CicRiXOQ03t7eDst8fHxcMIlzMC5ymsWLFyMiIsJ2OS0tDZMnT3bhRGLxPRc5Tb9+/VBUVIRvvvkGQUFBmDZtGmQymavHEoZxkVMFBATg4YcfdvUYTsGXhUSCMC4iQRgXkSCMi0gQxkUkCOMiEoSb4smpysrK8PnnnyMwMBCPPPII/Pz8XD2SMIyLnKagoADjxo1Da2srAGD16tU4duwYPDw8XDyZGHxZSE7z4Ycf2sICrIefZGRkuHAisRgXOY1S6fhCyV3XWgDjIid68sknERQUZLs8fvx4pKWluXAisfiei5wmMTERp06dwpdffong4GDMmjULCoXC1WMJw7jIqSIjI7F48WJXj+EUfFlIJAjjIhKEcREJwriIBGFcRIIwLiJBGBeRIIyLSBDGRSQI99AgpyotLbU7nsvf39/VIwnDuMhprnY8V05OjtvuGc+XheQ0q1evtjueKz8/n8dzEXWHq62h3HWtBTAucqInn3wSwcHBtss8nouom1x5PNfMmTN5PBdRd4mIiMBTTz3l6jGcgi8LiQRhXESCMC4iQRgXOd3FixfR3Nzs6jGEY1zkNHq9HjNmzEBERATCw8OxfPlyV48kFOMip1m1ahU2b94MAGhvb8eLL76IgoICF08lDuMip7laSIyLqBvcdddddpe9vLyQmprqmmGcgHGR0zzwwAN47733MHz4cKSmpmLr1q0IDw939VjCcA8Ncqqnn34aTz/9tKvHcAquuYgEYVxEgjAuIkEYF5EgjItIEMZFJAjjIhKEcREJwriIBGFcRIIwLiJBGBeRIF3uuBsfH++MOYjcTpdxaTQaxMXFOWEUop5Fq9Ved+XDl4VEgjAuIkEYF5EgjItIEMZFJAjjIhKEcREJwriIBGFcRIIwLiJBGBeRIIyLSBDGRSQI4yIShHERCcK4iARhXESCMC4iQRgXkSCMi0gQxkUkCOMiEoRxEQnCuIgEYVxEgjAuIkEYF5EgjItIEMZFJAjjIhKEcREJwriIBGFcRIIwLiJBGBeRIIyLSBDGRSQI4yIShHERCcK4iARhXESCMC4iQRgXkSCMi0gQxkUkCOMiEoRxEQnCuIgEYVxEgjAuIkEYF5EgjItIEMZFJAjjIhKEcREJwriIBGFcRIIwLiJBGBeRIIyLSBDGRSQI4yIShHERCaLs6gbx8fHOmIPI7XQZl0ajQVxcnBNGIepZtFrtdVc+fFlIJAjjIhKEcREJwriIBGFcRIIwLiJBGBeRIIyLSBDGRSQI4yIShHERCcK4iARhXESCMC4iQRgXkSCMi0gQxkUkCOMiEoRxEQnCuIgEYVxEgjAuIkEYF5EgjItIEMZFJAjjIhKEcREJwriIBGFcRIIwLiJBGBeRIIyLSBDGRSQI4yKnKykpQVVVlavHEI5xkdM0Nzdj8uTJSEpKQkxMDH7/+9+7eiShGBc5zd/+9jfs2bMHAGA2m7FixQrk5eW5dCaRGBc5zZkzZ37UMnfBuMhpZs6caXfZ398fU6ZMcdE04jEucprp06dj7dq1SElJwb333osdO3YgODjY1WMJo3T1ANS7zJ8/H/Pnz3f1GE7BNReRIIyLSBDGRSQI4yIShHGR01ksFleP4BS9Lq49e/bgjjvuwKRJk7Bx40ZXj9OrmEwmLF68GN7e3oiMjMSaNWtcPZJY0jVoNBoJgKTRaK51kxtKS0uL9N5770nPP/+8dPTo0avepry8XFKpVBIA25+9e/c6edLe64MPPrD72cvlcqm0tNTVY/1kXTVyw33OtWvXLmRkZPzX91u3bh0qKioAACtXrsScOXMQERGBjIwM1NTUICEhAX5+fjAYDHb3+93vfveT9hJIT09HWlraf32/3uzIkSN2ly0WC7KystC/f38XTSTWDRdXVy5cuACdToe+ffsiJCQEAFBVVWULCwAkSUJOTg6MRiPKy8sBANXV1UhKSnJ4vM7HIPEmTZqETz75xHZZqVQiOTnZdQOJ9lNXea7w5ptv2r2kWL9+vSRJklRYWGj3cgOAdP/99zssi46Olp5++mlJLpdLAKR7771X2rlzp/TGG29I27dvd/Gzc39ms1l64YUXpJCQECkxMVHauHGjq0f6WbpqpMfEZTQaJT8/P7tYhgwZIhmNRunrr7+WkpOTbct9fX2lI0eOSNHR0Xa3T01NlSRJknQ6nVReXi69//77dte/+uqrLn6W1JN01UiP2VposVgc3i+1tbVh0qRJuO+++3Do0CGEhobirbfeQnFxMRITE/GnP/0JKpUKABAdHQ0A8PLywj333IO6ujqsWLHC7vFWrlzZazYTu0pubi6effZZvPbaa7h48aKrxxGqx7znUqlU+OUvf4lVq1bZlqWmptq9hq+pqUF7ezveffddrFy5EiaTCfHx8Zg0aRLMZjPWrVsHAMjKysLs2bOd/RR6vezsbEycOBFGoxEAsHbtWhQUFECtVrt4MjF+dlwfffQRysrKumOWLun1esTGxqKtrQ1Dhw5FbW2tw202bNiA/Px822WNRoOAgABotVq725WUlGDSpEk4e/asbdnIkSPx4osvCpv/evr3749f/epXLvm7u/JTt+Be6fvvv7eFBQBlZWV4+OGHr7qh6b91I269/dlxlZWVIf9UERTqwG4Y59oM7Xrs2PolTB0dAID9+/djQuqd8PL2gb6tFQCgUCphkTv+FqxvbIGvfzAaGhpsy7x9fBEY0R+3TvZFTbUOQcGhCImMweky5584xdze0OVt3EHnS/TLeXp6umAS5+iWl4UKdSC8+4k9ovTCiT22sADr5va6VjlS7n8BRVlb4OnliwGj0uHh6Y2iUydgNl36DdluVqGuSgMPlTc6jHoEhvbB2Dseg09UAnzigD4AzCYjzhYeQbu+GX0HjIVPQKjQ53O5tvKdTvu7foq0tLSftFZoaWlBcXExbrrpJqhUKpw7dw7jx49HZWUlAGDq1Kn497//DZlM1t0j3xB6zHsuL99Ah2VtzXXIWPcKJMkCucIDUXHDEJM4Cqmz/y8KDn6NDqMeSk81qsoLbPfx8Q/FHY+8Abn80rYcSbJg14b/h5pK6/kc8jO/Qvq8VxAY1kf483JX3377LebNm4empiaEhYVh06ZNSE5OxsqVK/HCCy8gKCgIX375pduGBfSgfQuj4ocjJnG07XJwZH/otPmQJOvWPYu5A3n7NsBoaMPFs6eh9gnA4LHT0d7aZPc4rU01OF+ai10blmPz6iXI3f0ZdOWnbGEBgKmjHWdyf/57jN5KkiQ89dRTaGqy/uyrq6uxZMkSrF69Gg899BDOnj2L48ePY+7cuS6eVKwbds1lNLSh/NRBmE1G9BucDC/fIEya+Szqq8phNhkRFBmPL/7ymN19DPpm7Pvq/6O6oggAoD2VibCYAXa3UXn7IztjDdpbGwAAhdlbYNA3O/z9kiShva0J54qOwkPlhT4DboFC6b7vD7qT0Wi022MGsL43/+ijj+yWfffdd6isrLR9TOJubsg1l8nYju3/ehnZOz5B7p7PsPWTZWhtsm4ZDIroh9CYJCgUSvQbMtHufjEJo2xhdTKbTQiLHQQAUHn5Yci4e21hdWqqu4CQqETbZaWHCrFJY7Dln79H9o5PcOi7D7Dj89dhsZgFPFv3o1KpMH36dLtl999/PwIDA+2WeXp64t1338XYsWOxYMEChyB7uhtyzVVRcgzN9TrbZYO+GZr8ffD2D0FxznYolJ64afwM3DJ1EQJDY1GrK0N4n8GITRoNTcF+SJdF4KHyQu2FUtvjlOTtgNJDDVNHu+02wRFxGHHbXJzY/z9oa6rBoHHTcb4kx26NVqfT4ILmBGISbnbCT6DnW7t2LV599VVkZ2dj8uTJePHFF5GVlYVDhw6hra0NADBu3Di8+eabAKyfPebn5+PYsWOuHLtb3ZBrLsDxTW5LYzWObP0Q9VVa1Jwvxv7/vA19cx38gqOgb66DJn8/qs8VYsi4S78xPVTe8PIJgsl4KaTmeh0SR6ZB5eUHAAjvOwTDJt6PI1tXozjne1SUHMOejW9C31znMIPENdePFhgYiAkTJiA6OhpGoxHNzc1ISUmBVqvFjBkzsGjRItTV2f+Mc3Jy7D537Ol+9pqrvr4e5vaGbt2cHKwywdcvAC3NjQAAlUoNS6vO7jYWixnFmWtRfPo4JEkCAGR+8z5SpkzH+JR0aEsL4empgrlN5/D4xgYtzCZrcJKhAdWnv8W54izb9aaOdujry6FUesBksm7+9/ULQICiTshmc3N7A+rr3ev93KeffoqFCxfaLm/fvh05OTm2/1Wr1YiJibG7T2BgIMLCwpw8qThdxhUfH3/d62+77Tb4BXTviR2VSiUm3X4PKs9pYDabENMnHrrKcyjXFNvdzmgw2MLqVFmhxTltCYwGazwymRweHp7o6LB+7uUfEAxNyWnb/aqrKqFSeznMIFcokDp1BirOlsHDwwN9+iVCoVB06/O8XGFhoVtvls7Ly7P7+ANwPJV1Q0MDvL29nTmWUF3GpdFoEBcXd83rly5ditNlVUI+RA5IvPy/TahvlVB++hDkcjkGjrkT4X0HQ1N62v5O6nAYDZd2f5IkC+KG3ga/oEhYLGYEhPXF3v/5s91dTDJvhMUMQPV5a7wymRyDJjyEsH43Ieymbn9aDtrKdyJ5yEDblxS4g3nz5uGzzz6zXVYoFJg9ezbWr19vd7v169dj+PDh6NOnD3x9fZ095s+i1Wqvu/K5ITdoXI1cocSE6U9hdNp8yBQKeKq8IUkSkkbejpLjuwBI6Dd4IqLjR6D0+C67+3YY9cg/+BWM7a3wDYyw7qlhaLNdHxU3DIkj0qAp2I/W5jr0HTgWwRHXX2PT9b300kvYuXOn7Xu4li5dCm9vb4e4BgwYgMGDB7tiROF6TFydVN5+tv+WyWQYk74Qw269H5LFArVPACwWCyL6DUVVuXXt5Rcchcqy4zC2W/c/bGmoQmjMAMjlCrQ116Lf4GQMGD0NcrkcSTenu+Q5uaPBgwdDo9HgwIEDiIuLQ1JSEpqamrBt2zbs27cPMpkMzz33HG6+2X23vvaYuCwWC3TakzB3GBDVfySUHpc2AHRu+bugOYHKsjzEJo3BkLHTYZHMCAiOxeYPf2P3WO2tjbh1xm9gbG9BWOxAh/cC1D28vLyQnn7pF5a/vz/27t2Lxx9/HJ6ennjrrbdcOJ14PSIui9mEnRuWo+aH90S+AeGY+vBrdmuxspN7cWTbpT0A+gwYi1tnPAOLxYzAsL5oqL60iVeuUGDbp8sAAH5BkZgy9yWHfReb66tg0DcjJKo/ZDLG153c+ZtNLtcj4qosy7OFBQAtjRdRenIPhoy7x7bsTO4Ou/ucK87CueKjOLbzX9C31MPD0wtqn0CERPWH9lSm7XbN9ToU53yPEZMetC07tnMtinO2AwACQmORNmcp1D4Bgp5d75aZmYljx45h8uTJGDZsmKvH6VbdEld3f851pZbKEodljefzsP2TPWioq0VoeCSkDvtTAMjlMmRv/wfa9dYNFx1GPQKDghAepIb2ysevKrTN39hQZwsLABprKpC/azWGDB8NUazHc0UIe3xXOnz4MLRaLaZOneqwxnr99dfx8ssvA7C+f163bh0eeughV4wpxM+OyxnnnIuPDsCZU7loaWkBAHh4eKClsRa1NTUAgKoLFYiOjkaTQgGz2boXxejRo5GVlWX3OPrWJqSMH4lTx4/YHgsAJiaPgZeXDA0NDQhw/MgLngozBvcX+Y8/olt/js48Ovx6Oj8wBqz7G/7iF79AZGQkysrKYDabsXnzZtttJUnCM888g5MnT7pqXDvdcWT4z47LWYemP/fcc1i9ejXa2towb948jB5tvybR6/UoKyvDtm3bMHz4cIwfPx4TJ07EwYMHbbeZM2cOgoODIUkSFAoFkpKS8Ne//hU7d+60nawmKCgIoaGhqPkhXABYsWIF7rrrLqc8z+5QVlaGM6cLEOkr/lX/uQsXcbq0HGq1J0YOSoK/r/VD4ObWNltYAGAwGHBgVwam3noLWmvroJDLbb8IO3UY2tF8zn7Ha1fQtZi65XF6xHsuAIiNjcXrr79uuzxixAgcP37cdjkxMRGTJ0+GRqPBnXfeibVr12LDhg1IT09HVVUV5s6di5kzZ2Lq1Km2+xQWFqK8vBwrV660Lauvr8edd96JqKgoVFdXY+HChT0qrE6Rvko8OlzshoOjJZVYtTsTnTvJXNRV4avnH4DKQ4kSHbD2itsHeViwY88+FFda9ylMiAhEaVWD7frHpwzHg4Jn/jHWnHDcr/Sn6DFxXWndunVYuHAhjh07hpSUFOTn56O+vh4AsGXLFixbtgxPP/00Ghsb0djYCI1Gg8OHDzs8zpEjRxxOp2YwGPDxxx875Xn0ZFtySnD53mdVja3IKqnEoJhQeCgUGN4vHCfKL50+LdBHjazSC7bLpVUNeOqO0Wg1dOCWhGiMH2C/r2FTmwG7C8rho/LAbUP6wkMpbvczEXpsXEOHDkV2djYkSUJRUZHDp/xZWVmYO3cuLlyw/p+5bds2dHR0QCaT2e2POGfOHOTn59udx3zRokXOeRI9XIif4xvU7cc1+O2nO2CRJIzoF47H029GdZMetw+Px/a8Uofb9wsLwJRh8fji8Gk89dEJxIb445dTRsIiSVjw3mbUtugBAEP7hOEfT06HUtFzPhbpOZNeg0wmQ2JiosMe1snJyTh16pTdsoKCAqxZswZJSUno168f3nnnHUydOhVbt27FK6+8gvnz52PTpk2YN2+eM59Cj/WLiTchNuTSZ40pg/tgS24JLD/88jpefhEeCgWWzZqIsYnRmDoyAZfvmxzgrcK4pBiszyzAn/9zEEdLKvHVkUL8n39+j68OF9rCAoD8c9U4XNyzDqbssWuuyymVSnz99dd4/PHHUVJSgpkzZ2LFihXYs2ePXWATJkzAggULsGDBArv7BwUF4dVXX3Xy1D1fqL83vnjuAeRodAj0VqG8uhH7T5+zu422uhH/2JGLU+drMKZ/FN6aPwWbs88gwEuF+bcNg6/aEztOaOzuU6qrx+AYxy/IMJh61vF0PX7N1Wnr1q3Iy8tDU1MTMjMzUVtbi/Xr1yMoKAgymQzjx4/H+++/7+ox3Y5SIcfYxGgMiA7B2KQY+Kg87K6vqG3C3zNysO/UWbz97REc117ES/ffitoWPR585yvMeftLeHna/473UMgxc+wgu+V9QvwxcVDPOhuXW6y5Kioq8Oqrr9o2TJSUlGD58uUICAiwbeQ4fPgwtm3bhkcffdSVo/YImYXnsDtfi9gQf8yeMBg+Kk8YOkzILKqAp0KO8QNir/reJ8BbhQ9+fSf+ues4mvQGTB+VhDe+PGB3my25JahpbsPBIutLvLKqBjTrjYgK8sWF+hYo5DIsnjYGI+Ii8O/f3IctOSXwUXninjFJUHs4/nM1dJiwLa8MuvoWTB7aDwOib5yvhHKbuK7c4qfRaLBv3z67ZStWrGBcXdiWW4qX1u+xXT5YVIG3Hrkdj/5tM87WWE+VdlOfMHz0xN3wvMrWuyGxYVj5yO0AAItFwvvbslDXcuk0C2H+3sg/W213n+qmNnzzwhzUNusRGeSLUD/rZ2V9QwPwxNTr7xnz208zcOSM9SSj/9ydh/cem4axiTfG2aTc4mXhmDFjkJCQYLfsgQcecNE0Pdt/jtp/iJuj0WHtnuO2sACg4Fw19p06C119C749dgaF52uufBgA1l3Qnp0+zraW8/JU4rYhfdEvzH4/zdgQP0QE+GJo33BbWIA1zlbDpTMnmy0WfHm4EC99vgfrMwtQXFlrC8t6vYQNmQW4UbjFmkupVGLHjh1Yvnw5zp49i7lz52LhwoU4c+aM3WEN99xzDyZOnIjq6mosWrQIL7zwggunvjH5edmfy0Muk8FkkRxul6fV4aX1e2AyW18xPHnHaDyWNhK6hhYcOH0OUUG+SB4QiztvTsTYxBgcKq7AX7ccxeqMXABARKAPGlsNSIgMwtKZE9BhNkOvNyHQx3qu/wOF57D8ywO42NSGMQlRWP7QZKzdcwLr9luP09uWV4r04Y4HtCq6OHyo1WDErpNaSBKQNiwOvmpx5y5xi7gAIC4uDh9++KHdshUrVkCr1aKqqgrLli3DrFmzbKf1Wrp0KaKiohy2HLqD+vp61LSYftSeBg1NLTheWIIOkwlDEuMQ1icensXnYeyw7gI0bGACEBQFD2UhOkzWZV5qFXacOm8LCwA+2pGHSrMXvtt9CKYfdmtKiovF1Im3AAD25VWg/rKXh1UNrZhz52SEBQfio0MaHMr7DsYOE/pFRyBt/Ch89u1uGIzWkwNll17Abz7LRNm5S2spANiVX46EPtEo/WG5QiFHUHRf2/M2my04p7sIpUKBmIhQdJhM2Lh1NxqbrQfO/mVbDmZPS4VaZR+YrsUE0w/v1X8Ot4mrtbUVa9asQUVFBWbPnm3b9zAhIQEJCQlob2+3hdXp+++/d8u4fqx2gxFfbt+L9h9eep3RVuD+O27DzPQUHMwtgGSxIDo8BIF+vpg9LRWnSrWQy+UYmhSPb3YdtHsss8WMvNMltrA6H2/s8MEI9PO1/R2XMxg70NKmx77sS2fwKq+swtGThbawOtXUN0Kt8rRbrlJ5YuqtY1FeqUNjcwvUKk/bSYTaDUZ8tX0v6pusO2hHh4ciqV+MLSwAaGppxRltBYYNFLPzudvENW3aNBw4YN0ytXLlSnz//fcYPHgwvvnmG1RVVeHChQsOe2eMGDHCVeMKFRQUBGXLxS73LdySU2L3j94iSVA0V2P/6bM4X2c9IWpFVQ3emj8FY+N8cCS7FqW6eigNLZg7fgA+2H7pBJ7TRiagWW9E+RV/R7SsGVl5xQhXA6UyoPMVZqifF4YHyeDv1eFwBq8wDzMiA32ga7gUwrRhfTCsbziWfbYbJrMFCrkML9w7DneNDEF1fzV++cF3tpnvGpWIpMhgW1gAUHmxBmPjHH8eoyPVmHfFz2nNiTr4BQVd92f3Y7hFXDk5ObawAMBsNmPVqlW4ePEiCgqsb3A//fRTJCcnIz8/Hy0tLbjvvvvwzDPPuGrkG0Kwr+N3mRlMJts/0k5bckpwRleHilrr8qMllfD3UuG1OZOwZvdxtBk64O+lwpRhcThYVGHbQ2NgdAje2nRpf05/L0+kDO6Lw8XnUdOsx+tf7EeYvze8VR5oM1xaIyUP7INfp4/Cys2HUVhZC7WHAi16A0bFR+I/z8/Gn/+TiWNlOqzOyIGnUoGCimq7mbfklODeMY5fqJcYEYxQP2/UNFtfwYT4emHayASH23WXGy6un/IthpcfHtLp1KlTKCwstFt28uRJPPHEEzCZTFCr1fjjH//4k+e8Eb/J8HK6H/GeS5K8EBcbCW2F9cSpwQH+UARGArDfYqhrhy2sTodLdSiqacW5auuJWzccPIUTVa24/47bUHquEv4+3jhfZb/JvUlvRGW7zG63puqmNtyUFIfa+ibUNTZBoVDgm/xK1HgEweTpgzaDDm2GDvznaDGyztajf2w0Mn/4jOx8XTOWfb4b8bFRDs+tUeYNhUIO8w/vC71UnqhXhWB6+m0oKjsLCRIG9e+HzRo9AL3dfXUtJvg5POJ/74aL66cIDQ3FoEGDbDF5enpi3LhxqKystH2NDQCEhIRAqVRCqXSLp31N/82Bl3MfHoQLFy7AaDSiT58+kMvlGFPbiuzsbABAQEAAUqfehYsbN9p9TW7fuHiHfTe1lRcxY/YvkDDSennPnj04U37e7jY+wREA7E8GGhgeA71ZDl1NHdBhQv4ZDSRPb5y7YB9nha4aPlecgNZikRDVtz9Kz17a2OHv749bbktH/6GjcPz4cSiVSowaNcr2RRCRA67/dsAP3XQQsHQNGo1GAiBpNJpr3eSGYjabpS1btkirV6+WKisrJUmSpO3bt0vh4eESACkxMVHKz8938ZQ9R2FhobR7927JaDRKkiRJJ0+elCZMmCD5+PhIs2bNkqqrq6W4uDgJgO3PzTffLI0bN07y8PCQpk2bJp04cUIaPHiw7fpRo0ZJd999t6RWq23L/P39paKiIkkmk9k9lr+/v5Sammq3LDIyUvrLX/5it0ypVEoVFRXSjh07pIcfflh69tlnpbNnzzrlZ9RVI24T17UYDAZJo9FIFovF1aO4nYyMDCksLEwCIPXt21fq37+/3T/8WbNmSSaTScrMzJSSk5Ptruvfv7/08ssvS6WlpZIkSVJSUpLd9bfccou0du1aKSoqSgIg+fn5SV999ZXU0dEhLV68WPL29pb69u0rrV+/3mXPv9fHRWK1t7dLRUVFUl1dnV0cAKSIiAhJkiSpsrLS4bqwsDBJkiQpNzdXSk9Pl2JiYiQfHx8JgBQeHi75+vra1mCrVq2SmpubXfk0r6qrRtxi9ydyHZVKhQEDBiAoKAg33WR/Yv3ExEQsWrQIb7/9Nry87A+s9PX1hdFoxN13342MjAycP38era2t+O1vf4uQkBDbCYSamprw9ttv97jzyANuskGDbgyff/45HnvsMeTm5mLEiBHIzMxEZqb1HJEREREwGo0wm81QKpUIDQ3FoUOHUFlpv9dFdnY2ysvtPy3TarXOegrdimsu6jbDhg3D0aNH0dHR4bC1raqqCitWrIBarYbJZEJWVhaefPJJh68MGjZsGGbPnm237MrLPQXXXCTE1U5ZnZOTg/b2S/sXnj59Gs8//zw+/vhj1NXVYdKkSXjllVfg6+uLmJgYHDhwAMnJyfjDH/7gzNG7DeMiIZ5//nls2rQJOp31A+pFixY5fOE4YP0w/o033kBjY6Pdt0r+6U9/ctaowjAuEiIhIQElJSXYuXMnoqOjMWbMGJSUlOCTTz6xfRdycnIypkyZArlc7lZf19qJcZEwPj4+iIqKwiuvvILq6mo8+uijOH36NObPnw+1Wo2NGze69dc3MS4SprGxEenp6WhstO5/mJWVhZCQEIwaNQqAdTO+O3PfXxvkcnv37rWF1WnTpk0umsb5GBcJM3DgwKsu/+KLL/Dtt9/i9OnTV73eXTAuEmbgwIF4/fXX4elpPYx+5MiR+Oyzz1BSUoL8/HykpKTYHbXgbviei7r0U46xu9xTTz0Fg8Fg93VOAFBbW4sFCxZg0KBBP3fEG/L4OsZFwqnVaqjVavj5OR6C6O/v74KJnINxUZfS0tK6Za1QV1eHKVOmIC8vD4D1ixOvPGOXO2Fc5DTBwcHIyclBdnY2AgMDkZTkeJ4Ld8K4yKlkMhluueUWV4/hFNxaSCQI4yIShHERCcK4iARhXESCMC4iQRgXkSCMi0gQxkUkCOMiEuSauz+ZfviKzoqKCqcNQ9STdLbR2cqVrhlX5ymxUlJSBIxF5D50Oh0SExMdlssk6YrvzPxBe3s7srOzERkZ6fbfZ0X0U5hMJuh0OowZMwZqteO3dF4zLiL6ebhBg0gQxkUkCOMiEoRxEQnyv+/OJZxrEqCSAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 259.2x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 259.2x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "val = df.columns[df.columns.str.contains('Thiorhodospira')].values[0]\n",
    "ax=make_shannon_plot(df, \n",
    "                      md\n",
    "                     )\n",
    "add_15_percent_to_top_ylim(ax)\n",
    "if hide_axes:\n",
    "    ax.set(yticklabels=[], \n",
    "           xticklabels=[])\n",
    "    plt.xlabel(None)\n",
    "    plt.ylabel(None)\n",
    "    plt.title(None)\n",
    "plt.savefig(save_path+'-Shannon.pdf', \n",
    "            dpi=900, \n",
    "            bbox_inches='tight', \n",
    "            format='pdf'\n",
    "           )\n",
    "plt.show()\n",
    "\n",
    "ax=make_ra_feature_plot(df, \n",
    "                      md, \n",
    "                      val\n",
    "                      )\n",
    "add_15_percent_to_top_ylim(ax)\n",
    "if hide_axes:\n",
    "    ax.set(yticklabels=[], \n",
    "           xticklabels=[])\n",
    "    plt.xlabel(None)\n",
    "    plt.ylabel(None)\n",
    "    plt.title(None)\n",
    "plt.savefig(save_path+'-RA.pdf', \n",
    "            dpi=900, \n",
    "            bbox_inches='tight', \n",
    "            format='pdf'\n",
    "           )\n",
    "plt.show()\n",
    "\n",
    "ax=make_ra_feature_plot(df, \n",
    "                        md, \n",
    "                        val,\n",
    "                        pseudocount=1\n",
    "                      )\n",
    "add_15_percent_to_top_ylim(ax)\n",
    "if hide_axes:\n",
    "    ax.set(yticklabels=[], \n",
    "           xticklabels=[] )\n",
    "    plt.xlabel(None)\n",
    "    plt.ylabel(None)\n",
    "    plt.title(None)\n",
    "plt.savefig(save_path+'-RA-with-pseudocount.pdf', \n",
    "            dpi=900, \n",
    "            bbox_inches='tight', \n",
    "            format='pdf'\n",
    "           )\n",
    "\n",
    "plt.show()\n",
    "\n",
    "\n",
    "\n",
    "ax=make_clr_feature_plot(df, \n",
    "                      md, \n",
    "                      val\n",
    "                      )\n",
    "add_15_percent_to_top_ylim(ax)\n",
    "if hide_axes:\n",
    "    ax.set(yticklabels=[], \n",
    "           xticklabels=[])\n",
    "    plt.xlabel(None)\n",
    "    plt.ylabel(None)\n",
    "    plt.title(None)\n",
    "plt.savefig(save_path+'-CLR.pdf', \n",
    "            dpi=900, \n",
    "            bbox_inches='tight', \n",
    "            format='pdf'\n",
    "           )\n",
    "plt.show()\n",
    "\n",
    "\n",
    "ax=make_clr_feature_plot(df, \n",
    "                         md, \n",
    "                         val,\n",
    "                         pseudocount='one'\n",
    "                          )\n",
    "ax.set_xlabel(xaxis_name)\n",
    "add_15_percent_to_top_ylim(ax)\n",
    "if hide_axes:\n",
    "    ax.set(yticklabels=[], \n",
    "           xticklabels=[])\n",
    "    plt.xlabel(None)\n",
    "    plt.ylabel(None)\n",
    "    plt.title(None)\n",
    "plt.savefig(save_path+'-CLR-pseudocount-one.pdf', \n",
    "            dpi=900, \n",
    "            bbox_inches='tight', \n",
    "            format='pdf'\n",
    "           )\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6d75f5f",
   "metadata": {},
   "source": [
    "## fig 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "646cef7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('Kraken-TCGA-Raw-Data-17625-Samples.csv', index_col=0)\n",
    "md = pd.read_csv('Metadata-TCGA-All-18116-Samples.csv', index_col=0).loc[df.index]\n",
    "md = md.loc[ md.sample_type == 'Primary Tumor' ]\n",
    "df=df.loc[df.index.isin(md.index)]\n",
    "md=md.loc[md.index.isin(df.index)].loc[df.index]\n",
    "\n",
    "cols=  pd.read_csv('Kraken-TCGA-Voom-SNM-All-Putative-Contaminants-Removed-Data.csv', \n",
    "            index_col=0, nrows=1).columns\n",
    "df = df.loc[:, cols[cols.str.contains('contaminant')==False]]\n",
    "\n",
    "md['grouping'] = md.disease_type=='Lung Squamous Cell Carcinoma'\n",
    "xaxis_name = 'Lung Squamous Cell Carcinoma'\n",
    "\n",
    "save_path = 'tcga_plots-no-axes/Fig-4-Lung-Squamous-Cell-Carcinoma-Nitrospira'\n",
    "val = 'k__Bacteria.p__Nitrospirae.c__Nitrospira.o__Nitrospirales.f__Nitrospiraceae.g__Nitrospira'\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "11ca8f58",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_vsnm = pd.read_csv('Kraken-TCGA-Voom-SNM-All-Putative-Contaminants-Removed-Data.csv', \n",
    "                      index_col=0 ).loc[md.index]\n",
    "plt.figure(figsize=(12,7))\n",
    "ax=sns.histplot(x=df_vsnm[val].values, \n",
    "                hue = md.grouping.values, \n",
    "                bins=30\n",
    "                )\n",
    "ax.set_yticks(np.linspace(0, 1500, 4)) \n",
    "if hide_axes:\n",
    "    ax.get_legend().remove()\n",
    "    ax.set(\n",
    "           yticklabels=[], \n",
    "           xticklabels=[])\n",
    "    plt.xlabel(None)\n",
    "    plt.ylabel(None)\n",
    "    plt.title(None)\n",
    "plt.savefig(save_path+'-VSNM.pdf', \n",
    "            dpi=900, \n",
    "            bbox_inches='tight', \n",
    "            format='pdf'\n",
    "            )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9204bcec",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 259.2x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAANcAAAGKCAYAAACfGtQoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAM9klEQVR4nO3d32sc5QLG8WfTPZqCvcg2lRVr3S2CUuFcFX9hJGkrBLX3c3su9MY/wPofFPHeC0G9XESvFAk0bQJBUamgwumxHMguacSlrbPCiTZHtplzEbbHad0stvPM7L7z/cCCbxuHN9Vv38nMzruVJEkSAcjcVNETAEJFXIAJcQEmxAWYVIf9xvb2ti5evKh6va5qdeiXAaXV7/fV7XZ1/PhxTU9P3/kFyRBra2uJJF68eI14ra2t/WlDQ5eker0uSVpbW9Phw4eHfRlQWpubm5qbm7vVyu2GxjU4FTx8+LAajYZlckAIhv3YxAUNwIS4ABPiAkyICzAhLsCEuAAT4gJMiAswIS7AhLgAE+ICTIgLMCEuwIS4ABPiAkyICzAhLsCEuAAT4gJMiAswIS7AhLgAE+ICTEbuU91sNvOYBxCckXG12202BQX+RKfT2XPx4bQQMCEuwIS4ABPiAkyICzAhLsCEuAAT4gJMiAswIS7AhLgAE+ICTIgLMCEuwIS4ABPiAkyICzAhLsCEuAAT4gJMiAswIS7AhLgAE+ICTIgLMCEuwIS4ABPiAkyICzAhLsCEuAAT4gJMiAswCT6uOI515swZ9Xq9oqeCkgk+rlarpUuXLqnVahU9FZRM0HHFcazz588rSRItLy+zeiFXQcfVarW0s7MjSdrZ2WH1Qq6Cjmt1dVX9fl+S1O/3tbKyUvCMUCZBxzU/P69qtSpJqlarWlhYKHhGKJOg44qiSFNTu9/i1NSUoigqeEYok6DjqtVqOnnypCqVik6dOqWZmZmip4QSqRY9AbcoirSxscGqhdwFH1etVtPZs2eLngZKKOjTQqBIxAWYEBdgQlyACXEBJsQFmBAXYEJcgAlxASbEBZgQF2BCXIDJyDfuNpvNPOYBBGdkXO12W41GI4epAJOl0+nsufhwWgiYEBdgQlyACXEBJsQFmBAXYEJcgAlxASbEBZgQF2BCXIAJcQEmxAWYEBdgQlyACXEBJsQFmBAXYEJcgAlxASbEBZgQF2BCXIAJcQEmxAWYEBdgQlyACXEBJsQFmBAXYEJcgAlxASbEBZgQF2BCXIAJcQEmxAWYEBdgQlyACXEBJsQFmBAXYEJcgAlxASbEBZgQF2BCXIAJcQEmxAWYEBdgQlyACXEBJsQFmBAXYFId9QXNZjOPeQDBGRlXu91Wo9HIYSrAZOl0OnsuPpwWAibEBZgQF2BCXIAJcQEmxAWYEBdgQlyACXEBJsQFmBAXYEJcgAlxASbEBZgQF2BCXIAJcQEmxAWYEBdgQlyACXEBJsQFmBAXYEJcgAlxASbEBZgQF2BCXIAJcQEmxAWYEBdgQlyACXEBJsQFmBAXYEJcgAlxASbEBZgQF2BCXIAJcQEmxAWYEBdgQlyACXEBJsQFmBAXYEJcgAlxASbEBZgQF2BCXIAJcQEmxAWYEBdgUh31Bc1mM495AMEZGVe73Vaj0chhKsBk6XQ6ey4+nBYCJsQFmBAXYEJcgAlxASbEBZgQF2BCXIAJcQEmxAWYEBdgQlyACXEBJsQFmBAXYEJcgAlxASbEBZgQF2BCXIAJcQEmxAWYEBdgQlyACXEBJsQFmBAXYEJcgAlxASbEBZgQF2BCXIAJcQEmxAWYEBdgQlyACXEBJsQFmBAXYEJcgAlxIXdxHOvMmTPq9XpFT8WKuJC7VqulS5cuqdVqFT0VK+JCruI41vnz55UkiZaXl4NevYgLuWq1WtrZ2ZEk7ezsBL16ERdytbq6qn6/L0nq9/taWVkpeEY+xIVczc/Pq1qtSpKq1aoWFhYKnpEPcSFXURRpamr3f7upqSlFUVTwjHyIC7mq1Wo6efKkKpWKTp06pZmZmaKnZFMtegIonyiKtLGxEfSqJREXClCr1XT27Nmip2HHaSFgQlyACXEBJsQFmBAXYDLyamGz2cxjHkBwRsbVbrfVaDRymIpHHMd666239MYbbwR9wxL563Q6ey4+wZ8WluXZIYyfoOOK41jLy8tKkkTnzp0L+tkhjJ+g42q1WqnHG1i9kKeg41pZWVGSJJKkJEl04cKFgmeEMgk6rkOHDqXGDz74YEEzwR+xQU0Arl27tucYxSjLRaag41pYWFClUpEkVSqVoJ96nRRsUBOIKIpSj5SH/vzQJGCDmkDUajXV63VJ0kMPPcRN5DHABjWBiONY3W5XkvTTTz8FfQoyKdigJhCtVit1KT7kU5BJwQY1gSjTKcikKNMGNUHHNT8/z9XCMRRFkY4dOxb0qiUFHtfi4mLqtHBxcbHgGUH6/wY1Ia9aUuBxLS0tpVaupaWlgmeEMgk6rtXV1dTKxc9cyFPQcZXpsi/GT9BxlemyL8ZP0HGV6bIvxk/w21mXZV9yjJ/g4yrLvuQYP0GfFmI88bAkYMLDkoABD0sCJjwsCZiU6UkF4kKuyvSuGeJCrsr0rhniQq7K9K4Z4kLuFhcXtX///uCfryMu5G5paUk3btwI/vk64kKuuM8FmHCfCzDhPhdgwn0uwCSKotSmQdznAjJSpv37iQu5KtP+/cHHVZYH8yZFmfbvDz6usjyYNym4WhiIMt2wnBRcLQxEmW5YTgreFR+IMp2CTIparabnn39ekjQ3N8fVwkk1Pz+vffv2SZL27dsX9CnIJBlc0Ahd0HFFUaSbN29K2j0tDPkUZFLEcazPP/9ckrS2thb0z8FBx/XLL7/c+uckSVJjFKPVat36C+/mzZtB/xwcdFxvv/32nmPkb3V1NRVXyD8HBx3XlStXUuONjY2CZoKBZ555JjV+7rnnCpqJX9BxTU9P7zlG/gZv2i2DoOPa3t7ec4z8ffHFF3uOQxJ0XBg/hw4d2nMcEuJCrq5du5YaX716taCZ+AUd17Fjx1LjJ598sqCZYGBhYSH1sOSJEycKnpFP0HHdfl+L+1zFi6Io9a6ZkG/sj/xkyWazmcc8LF5++eXU1anNzc1SXa0aVy+88IIOHDigOI5Vq9WKno7NyJWr3W4rSZKJfB05ciT1vTz66KOFz6nsr59//lkHDx5UpVLRwYMHFcdx4XO621e73b63uCbZK6+8khqfPn26oJlggCeRA/HBBx+kxu+9914xE8EtZXoMKOi4bty4secY+eNJZMCEfQsBk1qtpvvuu0+SdP/99/MkMpCV9fV1/frrr5Kkra2tkVfcJhlxIVdlesYu6LhmZ2dT45DfJDopyvSMXdBxXb9+PTW+/U2jyN/gSuGwcUiCjgvjZ3CPa9g4JMSFXD3yyCOp8e1vUQsJcSFXr776amr82muvFTQTP+JCrj7++OPU+KOPPipoJn7EhVx99913qfG3335bzERyQFyACXEhV4OnkIeNQ0JcyNXjjz+eGj/xxBMFzcSPuJCry5cvp8Y//PBDQTPxIy7kavBhhMPGISEu5GrwqZLDxiEJ9zvDWHr66adT42effbagmfgRF3JVpq3tiAu5+uqrr1LjL7/8sqCZ+BEXcjXYVm3YOCTEhVzdvmdGqXfcBbJUpgdYiQswIS7AhLiQq8GehcPGISEu5Or333/fcxwS4gJMiAswIS7AJNwdGZGZCxcu6Ny5c7bjv/nmm/d8jBdffHHsPryclQswYeXCSCdOnMhsVfjss8/0zjvv3Bq//vrrWlxczOTY44aVC7l66aWXUuNQw5KICwWo1+uSdletkHFaiNzNzs5qdnY26FVLYuUCbIgLMCEuwIS4ABPiAkyICzDhUnyA3n33Xa2vrxc9jaEGc8viPYUuR48eveNTMP8q4grQ+vq6/v2vf6r+wHj+592f7O4P/58rl0d8ZTG6W9l8CPp4/unjntUfqOoffw932zKn97+PMzkOP3MBJsQFmHBaGKBer6frW/3MTm/KprvVV7/Xu+fjsHIBJmO3ck3CI+XSeD5WPjAzM6Pq1lUuaNyl97+PdeC2Pe3vxj3HlfU9lV6vp14GS/IwWc31ww8/zPQvgSzuq/xRd4xPC7d+370U/8B943ni1N3q60AGx7nnuL755hv9+OOPGUwlH7/99ltmx8ny++71epnFdfTo0UyOM5D1X3jb/92WJN2o/C2zY87MzNzxCSp364Cy+TOsJEM+IKnT6ajZbI48wFNPPZXZNyXtfvJglp+TW6lUVKlUlCRJpp8FtbOzk+nxer2evv7668yOl6WHH35YR44cyex4gy2ss9xtd2Njo7C/5NvtthqNxh2/PnLlGvYvTorTp09L2o3s008/LXg2CMmoBWg8T3qBAIzd1cKsffLJJ0VPASXFygWYEBdgQlyACXEBJsQFmBAXYEJcgAlxASbEBZgQF2Ay9O1P/f7u9lKbm5u5TQaYJIM2Bq3cbmhc3W5XkjQ3N2eYFhCObrerxx577I5fH/o81/b2ti5evKh6va5qNfj39wJ/Wb/fV7fb1fHjxzU9PX3H7w+NC8C94YIGYEJcgAlxASbEBZj8D5jgAaDMU65vAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 259.2x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 259.2x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 259.2x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 259.2x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax=make_shannon_plot(df, \n",
    "                      md\n",
    "                     )\n",
    "ax.set_xlabel(xaxis_name)\n",
    "# ax.set_ylim(2.8, 6.5)\n",
    "add_15_percent_to_top_ylim(ax)\n",
    "if hide_axes:\n",
    "    ax.set(yticklabels=[], \n",
    "           xticklabels=[])\n",
    "    plt.xlabel(None)\n",
    "    plt.ylabel(None)\n",
    "    plt.title(None)\n",
    "plt.savefig(save_path+'-Shannon.pdf', \n",
    "            dpi=900, \n",
    "            bbox_inches='tight', \n",
    "            format='pdf'\n",
    "           )\n",
    "plt.show()\n",
    "\n",
    "ax=make_ra_feature_plot(df, \n",
    "                        md, \n",
    "                        val\n",
    "                        )\n",
    "ax.set_xlabel(xaxis_name)\n",
    "# ax.set_ylim(-0.0001, 0.003)\n",
    "add_15_percent_to_top_ylim(ax)\n",
    "if hide_axes:\n",
    "    ax.set(yticklabels=[], \n",
    "           xticklabels=[])\n",
    "    plt.xlabel(None)\n",
    "    plt.ylabel(None)\n",
    "    plt.title(None)\n",
    "plt.savefig(save_path+'-RA.pdf', \n",
    "            dpi=900, \n",
    "            bbox_inches='tight', \n",
    "            format='pdf'\n",
    "           )\n",
    "plt.show()\n",
    "\n",
    "ax=make_ra_feature_plot(df, \n",
    "                        md, \n",
    "                        val,\n",
    "                        pseudocount=1\n",
    "                      )\n",
    "ax.set_xlabel(xaxis_name)\n",
    "add_15_percent_to_top_ylim(ax)\n",
    "if hide_axes:\n",
    "    ax.set(yticklabels=[], \n",
    "           xticklabels=[] )\n",
    "    plt.xlabel(None)\n",
    "    plt.ylabel(None)\n",
    "    plt.title(None)\n",
    "plt.savefig(save_path+'-RA-with-pseudocount.pdf', \n",
    "            dpi=900, \n",
    "            bbox_inches='tight', \n",
    "            format='pdf'\n",
    "           )\n",
    "\n",
    "plt.show()\n",
    "\n",
    "\n",
    "\n",
    "ax=make_clr_feature_plot(df, \n",
    "                      md, \n",
    "                      val\n",
    "                      )\n",
    "ax.set_xlabel(xaxis_name)\n",
    "add_15_percent_to_top_ylim(ax)\n",
    "if hide_axes:\n",
    "    ax.set(yticklabels=[], \n",
    "           xticklabels=[])\n",
    "    plt.xlabel(None)\n",
    "    plt.ylabel(None)\n",
    "    plt.title(None)\n",
    "plt.savefig(save_path+'-CLR.pdf', \n",
    "            dpi=900, \n",
    "            bbox_inches='tight', \n",
    "            format='pdf'\n",
    "           )\n",
    "plt.show()\n",
    "\n",
    "ax=make_clr_feature_plot(df, \n",
    "                         md, \n",
    "                         val,\n",
    "                         pseudocount='one'\n",
    "                          )\n",
    "ax.set_xlabel(xaxis_name)\n",
    "add_15_percent_to_top_ylim(ax)\n",
    "if hide_axes:\n",
    "    ax.set(yticklabels=[], \n",
    "           xticklabels=[])\n",
    "    plt.xlabel(None)\n",
    "    plt.ylabel(None)\n",
    "    plt.title(None)\n",
    "plt.savefig(save_path+'-CLR-pseudocount-one.pdf', \n",
    "            dpi=900, \n",
    "            bbox_inches='tight', \n",
    "            format='pdf'\n",
    "           )\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4618ba3f",
   "metadata": {},
   "source": [
    "## fig 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "cb81c632",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('Kraken-TCGA-Raw-Data-17625-Samples.csv', index_col=0)\n",
    "md = pd.read_csv('Metadata-TCGA-All-18116-Samples.csv', index_col=0).loc[df.index]\n",
    "md=md.loc[(md.primary_site=='Head and Neck')&\\\n",
    "          (md.sample_type.str.contains('Blood')==False)\n",
    "         ]\n",
    "\n",
    "\n",
    "md.loc[md.sample_type.str.contains('Metastatic'), 'sample_type'] = 'Primary Tumor'\n",
    "df=df.loc[df.index.isin(md.index)]\n",
    "md=md.loc[md.index.isin(df.index)].loc[df.index]\n",
    "\n",
    "md = md.sort_values('sample_type', ascending=False)\n",
    "df=df.loc[md.index]\n",
    "\n",
    "\n",
    "cols = pd.read_csv('Kraken-TCGA-Voom-SNM-Most-Stringent-Filtering-Data.csv', \n",
    "                   index_col=0, \n",
    "                   nrows=1).columns\n",
    "df = df.loc[:, cols[cols.str.contains('contaminant')==False]]\n",
    "\n",
    "md['grouping'] = md.sample_type\n",
    "\n",
    "val ='k__Viruses.o__Caudovirales.f__Myoviridae.g__Mulikevirus'\n",
    "save_path = 'tcga_plots-no-axes/Fig-5-Head-and-Neck-Mulikevirus'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "491ea5f0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_vsnm = pd.read_csv('Kraken-TCGA-Voom-SNM-Most-Stringent-Filtering-Data.csv', \n",
    "                        index_col=0).loc[md.index]\n",
    "plt.figure(figsize=(12,7))\n",
    "ax=sns.histplot(x=df_vsnm[val].values, \n",
    "                hue = md.grouping.values\n",
    "                )\n",
    "if hide_axes:\n",
    "    ax.get_legend().remove()\n",
    "    ax.set(\n",
    "           yticklabels=[], \n",
    "           xticklabels=[])\n",
    "    plt.xlabel(None)\n",
    "    plt.ylabel(None)\n",
    "    plt.title(None)\n",
    "plt.savefig(save_path+'-VSNM.pdf', \n",
    "            dpi=900, \n",
    "            bbox_inches='tight', \n",
    "            format='pdf'\n",
    "            )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "d7f5817f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 259.2x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 259.2x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAANcAAAGKCAYAAACfGtQoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAJoElEQVR4nO3dz2pbdxrH4VepCU5pIfZi6qFpa5kuZjWLIRsvQlKnAV+Ct7PIPdRXkN5DF936Egxp0hRDV1mVmZQyYLmZFDR/sA0TWhMUaxYZD7SJrKY6X0mWnwe0iZXDi+SPf9KRzjmtfr/fL6BxFyY9AMwqcUGIuCBEXBAyN+gHR0dH9fDhw1paWqq5uYF3g3Or1+tVt9utq1ev1vz8/Mt36A+ws7PTryo3N7cht52dnVc2NHBJWlpaqqqqnZ2dunLlyqC7wbn15MmTunbt2v9b+aWBcZ28FLxy5UotLy9HhoNZMOhtkx0aECIuCBEXhIgLQsQFIeKCEHFBiLggRFwQIi4IEReEiAtCxAUh4oIQcUGIuCBEXBAiLggRF4SIC0LEBSHighBxQYi4IERcECIuCBEXhIgLQsQFIeKCEHFBiLggRFwQIi4IEReEiAtCxAUh4oIQcUGIuCBEXBAyN+wO7XZ7HHPAzBkaV6fTqeXl5TGMAmfL3t7eqYuPl4UQIi4IEReEiAtCxAUh4oIQcUGIuCBEXBAiLggRF4SIC0LEBSHighBxQYi4GLv9/f365JNP6uDgYNKjRImLsdva2qpHjx7V1tbWpEeJEhdjtb+/X/fu3at+v19ffPHFTK9e4mKstra26vj4uKqqjo+PZ3r1Ehdj9eDBg+r1elVV1ev16ssvv5zwRDniYqxu3LhRc3Mvzos0NzdXH3300YQnyhEXY7WxsVEXLrz4tbtw4UJtbGxMeKIccTFWi4uLdfPmzWq1WvXxxx/XwsLCpEeKGXreQmjaxsZGPX78eKZXrSpxMQGLi4v16aefTnqMOC8LIURcECIuCBEXhIgLQsQFIeKCEHFBiLggRFyMncP8IcRh/hDgMH8IcZg/hDjMH0Ic5g8hDvOHEIf5Q5DD/CHEYf7ASMQFIeKCEHFBiLggRFwQIi4IEReEiIuxcyQyhDgSGQIciQwhjkSGEEciQ8iNGzeq1WpVVVWr1XIkMjRlfX29+v1+VVX1+/1aX1+f8EQ54mKstre3f7ZybW9vT3iiHHExVg8ePPjZyuU9FzTE2Z8gxNmfIOQ8nf1JXIzd+vp6Xbp0aab3FFaJiwnY3t6un376aab3FFaJizHz3UII8d1CCPHdQgjxOReE+JwLQs7T51wuxMDYucoJhLjKCTAScUGIuCBEXBAiLggZurew3W6PYw6YOUPj6nQ6tby8PIZRXrh//37dvXu3se0dHh5WVdXly5cb22ZV1a1bt2ptba3RbXK27O3tnbr4zPznXPv7+1XVfFwwzNTFtba21uiKsLm5WVVVd+7caWyb8GvYoQEh4oIQcUGIuCBEXBAiLggRF4SIC0LEBSHighBxQYi4IERcECIuCBEXhIgLQqbuYEmmz1k49cI0nnZBXIzdeTn1grgYyqkXfhvvuSBEXBAiLggRF4SIC0LEBSHighBxQYi4IERcECIuCBEXhIgLQsQFIeKCEHFBiLggRFwQIi4IEReEiAtCxAUh4oIQcUGIuCBEXBAiLggRF4SIC0LEBSHighBxQYi4IERcECIuCBEXhIgLQsQFIeKCEHFBiLggRFwQIi4IEReEiAtCxAUh4oIQcUGIuCBEXBAiLggRF4SIC0LEBSHighBxQYi4IGRu2B3a7fY45ohZXV2tqqpWqzXhSThxXp6ToXF1Op1aXl4ewygZm5ubVVX19ddfT3gSTszKc7K3t3fq4uNlIYSIC0LEBSHighBxQYi4IERcECIuCBEXhIgLQsQFIeKCEHFBiLggRFwQIi4IEReEiAtCxAUh4oIQcUGIuCBEXBAiLggRF4SIC0LEBSHigpChF2IY5rPPPqvd3d0mZok4me3k5P/TamVlpW7fvj3pMWjQyHHt7u7WXx59V2/MX25gnOYd996oqqpvd/8x4UkGe350OOkRCBg5rqqqN+Yv15sf3GxiU+fSj9/fm/QIBHjPBSHighBxQYi4IERcECIuCBEXhDTyORfTxbdmRtfEN2bENYN2d3frb9/+tZbems6n91L/uKqq/vP37yY8yat1n/Ya2c50PvqMbOmtufrzHxcnPcaZ9Pk3+41sx3suCBEXhIgLQsQFIeKCEHFBiLggRFwQIi4IEReEiAtCxAUh4oIQcUGIuCBEXBAiLggRF4SIC0LEBSHighBxQYi4IERcECIuCBn5jLsHBwf1/OjQdX1H8PzosA4OLk56DBpm5YKQkVeuhYWF6h48qzc/uNnEPOfSj9/fq4WFhUmPQcOsXBAiLggRF4SIC0Jc/G4GHRwc1L+f9hq7iNt5033aq97BwcjbsXJBiJVrBi0sLNTc03+6bOtv9Pk3+/V2Ax+NWLkgRFwQIi4IGfqeq91un/rz1dXV+t17f2hsoPPqq6++qlar1ci2VldX608rS41s67xq4vkYunJ1Op3q9/sDb9evXx9pAF64fv36qY/z69w8J6P7Nc9Hp9M5dRteFkKIuCBEXBAiLggRF4SIC0LEBSHighBxQYi4IERcECIuCBEXhIgLQsQFIeKCEHFBiLggRFwQIi4IEReEiAtCxAUh4oIQcUGIuCBEXBAiLggRF4SIC0LEBSHighBxQYi4IERcEDL0guOcTd2nvfr8m/1Jj/FKT58dV1XVWxen829792mv3m5gO+KaQSsrK5Me4VT/2t2tqqrfvzedc75dzTyG4ppBt2/fnvQIp9rc3Kyqqjt37kx4kqzpXJdhBogLQsQFIeKCkEZ2aDw/Oqwfv7/XxKYad9w7qqqqC3PzE55ksOdHh1X1zqTHoGEjxzXtu313/7fbd2Vlmn9535n6x5HXN3JcdvvCq3nPBSHighBxQYi4IERcECIuCBEXhIgLQsQFIeKCEHFBiLggRFwQIi4IEReEiAtCxAUh4oIQcUGIuCBEXBAiLggRF4SIC0LEBSHighBxQYi4IERcECIuCBEXhDRyZckm3b9/v+7evdvY9k4ufndyna6m3Lp1q9bW1hrdJrNl6uJq2uLi4qRHOPPOwh+8afxj1+r3+/1X/WBvb6/a7fa452EKvfvuu/X+++83tr2LFy9WVdWzZ88a2+bjx4/rhx9+aGx7r6PT6dTy8vJL/z505Rr0H+G8G7YA2aEBIeKCEHFBiLggRFwQIi4IEReEiAtCxAUh4oIQcUGIuCBk4Bd3e71eVVU9efJkbMPAWXLSxkkrvzQwrm63W1VV165dC4wFs6Pb7daHH3740r8PPJ7r6OioHj58WEtLSzU3N/PHVMJr6/V61e126+rVqzU/P//SzwfGBYzGDg0IEReEiAtCxAUh/wVmfpIIradjQwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 259.2x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 259.2x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 259.2x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax=make_shannon_plot(df, \n",
    "                  md\n",
    "                  )\n",
    "add_15_percent_to_top_ylim(ax)\n",
    "if hide_axes:\n",
    "    ax.set(yticklabels=[], \n",
    "           xticklabels=[])\n",
    "    plt.xlabel(None)\n",
    "    plt.ylabel(None)\n",
    "    plt.title(None)\n",
    "plt.savefig(save_path+'-Shannon.pdf', \n",
    "            dpi=900, \n",
    "            bbox_inches='tight', \n",
    "            format='pdf'\n",
    "           )\n",
    "plt.show()\n",
    "\n",
    "ax=make_ra_feature_plot(df, \n",
    "                      md, \n",
    "                      val\n",
    "                      )\n",
    "ax.set_yticks([0])\n",
    "if hide_axes:\n",
    "    ax.set(yticklabels=[], \n",
    "           xticklabels=[])\n",
    "    plt.xlabel(None)\n",
    "    plt.ylabel(None)\n",
    "    plt.title(None)\n",
    "plt.savefig(save_path+'-RA.pdf', \n",
    "            dpi=900, \n",
    "            bbox_inches='tight', \n",
    "            format='pdf'\n",
    "           )\n",
    "plt.show()\n",
    "\n",
    "ax=make_ra_feature_plot(df, \n",
    "                        md, \n",
    "                        val,\n",
    "                        pseudocount=1\n",
    "                      )\n",
    "add_15_percent_to_top_ylim(ax)\n",
    "if hide_axes:\n",
    "    ax.set(yticklabels=[], \n",
    "           xticklabels=[] )\n",
    "    plt.xlabel(None)\n",
    "    plt.ylabel(None)\n",
    "    plt.title(None)\n",
    "plt.savefig(save_path+'-RA-with-pseudocount.pdf', \n",
    "            dpi=900, \n",
    "            bbox_inches='tight', \n",
    "            format='pdf'\n",
    "           )\n",
    "\n",
    "plt.show()\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "ax=make_clr_feature_plot(df, \n",
    "                      md, \n",
    "                      val\n",
    "                      )\n",
    "add_15_percent_to_top_ylim(ax)\n",
    "if hide_axes:\n",
    "    ax.set(yticklabels=[], \n",
    "           xticklabels=[])\n",
    "    plt.xlabel(None)\n",
    "    plt.ylabel(None)\n",
    "    plt.title(None)\n",
    "plt.savefig(save_path+'-CLR.pdf', \n",
    "            dpi=900, \n",
    "            bbox_inches='tight', \n",
    "            format='pdf'\n",
    "           )\n",
    "plt.show()\n",
    "\n",
    "ax=make_clr_feature_plot(df, \n",
    "                         md, \n",
    "                         val,\n",
    "                         pseudocount='one'\n",
    "                          )\n",
    "ax.set_xlabel(xaxis_name)\n",
    "add_15_percent_to_top_ylim(ax)\n",
    "if hide_axes:\n",
    "    ax.set(yticklabels=[], \n",
    "           xticklabels=[])\n",
    "    plt.xlabel(None)\n",
    "    plt.ylabel(None)\n",
    "    plt.title(None)\n",
    "plt.savefig(save_path+'-CLR-pseudocount-one.pdf', \n",
    "            dpi=900, \n",
    "            bbox_inches='tight', \n",
    "            format='pdf'\n",
    "           )\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pl2",
   "language": "python",
   "name": "pl2"
  },
  "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.6.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}