2022_compartments.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# compartment-related analyses\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import h5py\n",
    "import bioframe\n",
    "from matplotlib.gridspec import GridSpec\n",
    "from matplotlib.gridspec import GridSpecFromSubplotSpec\n",
    "import matplotlib.colors as colors\n",
    "import cooler\n",
    "import seaborn as sns\n",
    "from matplotlib.colors import ListedColormap\n",
    "import matplotlib as mpl\n",
    "import os\n",
    "import glob\n",
    "import pairtools\n",
    "import random\n",
    "import bbi\n",
    "import cooltools\n",
    "import multiprocess as mp\n",
    "\n",
    "import cooltools.eigdecomp\n",
    "import cooltools.expected\n",
    "import cooltools.saddle\n",
    "import cooler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#naming \n",
    "pathDir = \"/nl/umw_job_dekker/users/as38w/JZ2022_git/coolers\"\n",
    "\n",
    "conditions = [\n",
    "    '1',\n",
    "    '2'\n",
    "]\n",
    "\n",
    "short_names = {\n",
    "    '1':'ND-dmso',\n",
    "    '2':'4OHT-dmso'\n",
    "}\n",
    "\n",
    "\n",
    "long_names = {\n",
    "    '1' : 'JZ-MEF-AsiS1-ND-dmso6h-HiCD2R1',\n",
    "    '2' : 'JZ-MEF-AsiS1-4OHT-dmso6h-HiCD2R1'    \n",
    "}\n",
    "\n",
    "\n",
    "coolerfile = {}\n",
    "for cond in conditions:\n",
    "    coolerfile[cond] = '{}/{}.mm10.nodups.65M.1000.mcool::resolutions/250000'.format(pathDir, long_names[cond])\n",
    "    \n",
    "clrs = {\n",
    "    cond: cooler.Cooler(coolerfile[cond]) for cond in conditions\n",
    "}\n",
    "binsize = 250000\n",
    "resolution=binsize\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'1': '/nl/umw_job_dekker/users/as38w/JZ2022_git/coolers/JZ-MEF-AsiS1-ND-dmso6h-HiCD2R1.mm10.nodups.65M.1000.mcool::resolutions/250000',\n",
       " '2': '/nl/umw_job_dekker/users/as38w/JZ2022_git/coolers/JZ-MEF-AsiS1-4OHT-dmso6h-HiCD2R1.mm10.nodups.65M.1000.mcool::resolutions/250000'}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coolerfile\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# calling compartments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO: Total memory requested is 96000 MB (4 cores x 24000 MB)\n",
      "Job <1549057> is submitted to queue <short>.\n",
      "INFO: Total memory requested is 96000 MB (4 cores x 24000 MB)\n",
      "Job <1549058> is submitted to queue <short>.\n"
     ]
    }
   ],
   "source": [
    "#Computing expected in cis/trans-check 100000\n",
    "for cond in conditions:\n",
    "    mcoolfile = coolerfile[cond]\n",
    "    expectedfile = '{}/{}.mm10.250000.cis.expected'.format(pathDir, long_names[cond])\n",
    "    !bsub -q short -W 04:00 -n 4 -R \"span[hosts=1]\" -R \"select[rh=8]\" -R rusage[mem=24000] \\\n",
    "        \"source activate coolerenv_manual_master; cooltools compute-expected -p 4 -t cis $mcoolfile -o $expectedfile\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO: Total memory requested is 96000 MB (4 cores x 24000 MB)\r\n",
      "Job <1549059> is submitted to queue <short>.\r\n"
     ]
    }
   ],
   "source": [
    "#make binned genome\n",
    "chromsizes = '/nl/umw_job_dekker/cshare/reference/sorted_chromsizes/mm10.reduced.chrom.sizes'\n",
    "mm10bins = '/nl/umw_job_dekker/users/as38w/JZ2022_git/coolers/mm10bins_250000'\n",
    "\n",
    "!bsub -q short -W 04:00 -n 4 -R \"span[hosts=1]\" -R \"select[rh=8]\" -R rusage[mem=24000] \\\n",
    "        \"source activate coolerenv_manual_master; cooler makebins -o $mm10bins $chromsizes 250000\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO: Total memory requested is 96000 MB (4 cores x 24000 MB)\r\n",
      "Job <1549061> is submitted to queue <short>.\r\n"
     ]
    }
   ],
   "source": [
    "#make gene_coverage track ... delete header\n",
    "mm10bins = '/nl/umw_job_dekker/users/as38w/JZ2022_git/coolers/mm10bins_250000'\n",
    "genecovfile = '/nl/umw_job_dekker/users/as38w/JZ2022_git/coolers/genecov_mm10_250000'\n",
    "\n",
    "!bsub -q short -W 04:00 -n 4 -R \"span[hosts=1]\" -R \"select[rh=8]\" -R rusage[mem=24000] \\\n",
    "        \"source activate coolerenv_manual_master; cooltools genome genecov $mm10bins mm10 > $genecovfile\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO: Total memory requested is 96000 MB (4 cores x 24000 MB)\n",
      "Job <1549066> is submitted to queue <short>.\n",
      "INFO: Total memory requested is 96000 MB (4 cores x 24000 MB)\n",
      "Job <1549067> is submitted to queue <short>.\n"
     ]
    }
   ],
   "source": [
    "for cond in conditions:\n",
    "    mcoolfile = coolerfile[cond]\n",
    "    compcallfile = '{}/{}.mm10.250000.compcall'.format(pathDir, long_names[cond])\n",
    "    referencetrack = '/nl/umw_job_dekker/users/as38w/JZ2022_git/coolers/genecov_mm10_250000'\n",
    "    \n",
    "    !bsub -q short -W 04:00 -n 4 -R \"span[hosts=1]\" -R \"select[rh=8]\" -R rusage[mem=24000] \\\n",
    "    \"source activate coolerenv_manual_master; cooltools call-compartments --reference-track $referencetrack --contact-type cis -o $compcallfile --bigwig $mcoolfile\"\n",
    "   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# saddleplots and relative compartment strength"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/as38w/miniconda3/envs/coolerenv_manual_master/lib/python3.7/site-packages/cooltools/saddle.py:147: RuntimeWarning: invalid value encountered in true_divide\n",
      "  return obs_mat / exp_mat\n",
      "/home/as38w/miniconda3/envs/coolerenv_manual_master/lib/python3.7/site-packages/cooltools/saddle.py:147: RuntimeWarning: invalid value encountered in true_divide\n",
      "  return obs_mat / exp_mat\n",
      "/home/as38w/miniconda3/envs/coolerenv_manual_master/lib/python3.7/site-packages/cooltools/saddle.py:147: RuntimeWarning: invalid value encountered in true_divide\n",
      "  return obs_mat / exp_mat\n",
      "/home/as38w/miniconda3/envs/coolerenv_manual_master/lib/python3.7/site-packages/cooltools/saddle.py:147: RuntimeWarning: invalid value encountered in true_divide\n",
      "  return obs_mat / exp_mat\n",
      "/home/as38w/miniconda3/envs/coolerenv_manual_master/lib/python3.7/site-packages/cooltools/saddle.py:147: RuntimeWarning: invalid value encountered in true_divide\n",
      "  return obs_mat / exp_mat\n",
      "/home/as38w/miniconda3/envs/coolerenv_manual_master/lib/python3.7/site-packages/cooltools/saddle.py:147: RuntimeWarning: invalid value encountered in true_divide\n",
      "  return obs_mat / exp_mat\n",
      "/home/as38w/miniconda3/envs/coolerenv_manual_master/lib/python3.7/site-packages/cooltools/saddle.py:147: RuntimeWarning: invalid value encountered in true_divide\n",
      "  return obs_mat / exp_mat\n",
      "/home/as38w/miniconda3/envs/coolerenv_manual_master/lib/python3.7/site-packages/cooltools/saddle.py:147: RuntimeWarning: invalid value encountered in true_divide\n",
      "  return obs_mat / exp_mat\n",
      "/home/as38w/miniconda3/envs/coolerenv_manual_master/lib/python3.7/site-packages/cooltools/saddle.py:147: RuntimeWarning: invalid value encountered in true_divide\n",
      "  return obs_mat / exp_mat\n",
      "/home/as38w/miniconda3/envs/coolerenv_manual_master/lib/python3.7/site-packages/cooltools/saddle.py:147: RuntimeWarning: invalid value encountered in true_divide\n",
      "  return obs_mat / exp_mat\n",
      "/home/as38w/miniconda3/envs/coolerenv_manual_master/lib/python3.7/site-packages/ipykernel_launcher.py:42: RuntimeWarning: invalid value encountered in true_divide\n",
      "/home/as38w/miniconda3/envs/coolerenv_manual_master/lib/python3.7/site-packages/cooltools/saddle.py:475: MatplotlibDeprecationWarning: Passing parameters norm and vmin/vmax simultaneously is deprecated since 3.3 and will become an error two minor releases later. Please pass vmin/vmax directly to the norm when creating it.\n",
      "  img = ax.pcolormesh(X, Y, C, norm=norm, **heatmap_kws)\n",
      "/home/as38w/miniconda3/envs/coolerenv_manual_master/lib/python3.7/site-packages/cooltools/saddle.py:147: RuntimeWarning: invalid value encountered in true_divide\n",
      "  return obs_mat / exp_mat\n",
      "/home/as38w/miniconda3/envs/coolerenv_manual_master/lib/python3.7/site-packages/cooltools/saddle.py:147: RuntimeWarning: invalid value encountered in true_divide\n",
      "  return obs_mat / exp_mat\n",
      "/home/as38w/miniconda3/envs/coolerenv_manual_master/lib/python3.7/site-packages/cooltools/saddle.py:147: RuntimeWarning: invalid value encountered in true_divide\n",
      "  return obs_mat / exp_mat\n",
      "/home/as38w/miniconda3/envs/coolerenv_manual_master/lib/python3.7/site-packages/cooltools/saddle.py:147: RuntimeWarning: invalid value encountered in true_divide\n",
      "  return obs_mat / exp_mat\n",
      "/home/as38w/miniconda3/envs/coolerenv_manual_master/lib/python3.7/site-packages/cooltools/saddle.py:147: RuntimeWarning: invalid value encountered in true_divide\n",
      "  return obs_mat / exp_mat\n",
      "/home/as38w/miniconda3/envs/coolerenv_manual_master/lib/python3.7/site-packages/cooltools/saddle.py:147: RuntimeWarning: invalid value encountered in true_divide\n",
      "  return obs_mat / exp_mat\n",
      "/home/as38w/miniconda3/envs/coolerenv_manual_master/lib/python3.7/site-packages/cooltools/saddle.py:147: RuntimeWarning: invalid value encountered in true_divide\n",
      "  return obs_mat / exp_mat\n",
      "/home/as38w/miniconda3/envs/coolerenv_manual_master/lib/python3.7/site-packages/cooltools/saddle.py:147: RuntimeWarning: invalid value encountered in true_divide\n",
      "  return obs_mat / exp_mat\n",
      "/home/as38w/miniconda3/envs/coolerenv_manual_master/lib/python3.7/site-packages/cooltools/saddle.py:475: MatplotlibDeprecationWarning: Passing parameters norm and vmin/vmax simultaneously is deprecated since 3.3 and will become an error two minor releases later. Please pass vmin/vmax directly to the norm when creating it.\n",
      "  img = ax.pcolormesh(X, Y, C, norm=norm, **heatmap_kws)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x576 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from cooltools import saddle\n",
    "\n",
    "QUANTILE_BINNING = True\n",
    "\n",
    "binedges = {}\n",
    "digitized = {}\n",
    "hist = {}\n",
    "sums = {}\n",
    "counts = {}\n",
    "saddledata = {}\n",
    "\n",
    "gs = plt.GridSpec(nrows=1, ncols=2)\n",
    "fig = plt.figure(figsize=(16, 8))\n",
    "histbins = 30\n",
    "\n",
    "for i, cond in enumerate(['1',\n",
    "                          '2']\n",
    "):\n",
    "    exp = pd.read_table(f'{pathDir}/{long_names[cond]}.mm10.250000.cis.expected')\n",
    "    eig = pd.read_table(f'{pathDir}/{long_names[cond]}.mm10.250000.compcall.cis.vecs.tsv')\n",
    "\n",
    "# Determine how to bin the range of the E1 signal\n",
    "    if QUANTILE_BINNING:\n",
    "        q_binedges = np.linspace(0.002, 0.998, histbins)\n",
    "        binedges[cond] = saddle.quantile(eig['E1'], q_binedges)\n",
    "    else:\n",
    "        qlo, qhi = saddle.quantile(eig['E1'], [0.02, 0.98])  # trim outliers\n",
    "        binedges[cond] = np.linspace(qlo, qhi, histbins)\n",
    "# Digitize the signal into integers\n",
    "    digitized[cond], hist[cond] = saddle.digitize_track(\n",
    "        binedges[cond], \n",
    "        track=(eig, 'E1'))\n",
    "# Construct a function that fetches and calculates observed/expected\n",
    "    getmatrix = saddle.make_cis_obsexp_fetcher(clrs[cond], (exp, 'balanced.avg'))\n",
    "    \n",
    "# Build the saddle histogram\n",
    "    sums[cond], counts[cond] = saddle.make_saddle(\n",
    "        getmatrix, \n",
    "        binedges[cond],\n",
    "        (digitized[cond], 'E1.d'), \n",
    "        contact_type='cis')\n",
    "    saddledata[cond] = sums[cond] / counts[cond]\n",
    "# Make the saddle plot\n",
    "    g = saddle.saddleplot(\n",
    "        q_binedges if QUANTILE_BINNING else binedges[cond],\n",
    "        hist[cond],\n",
    "        saddledata[cond], \n",
    "        color=\"palegoldenrod\",\n",
    "        heatmap_kws={'vmin': 0.3, 'vmax': 3}, \n",
    "        fig=fig, \n",
    "        subplot_spec=gs[i])\n",
    "\n",
    "#plt.savefig(\"\", bbox_inches='tight')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/as38w/miniconda3/envs/coolerenv_manual_master/lib/python3.7/site-packages/cooltools/saddle.py:562: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  inter = inter_sum / inter_count\n"
     ]
    }
   ],
   "source": [
    "strength = {\n",
    "    cond: saddle.saddle_strength(sums[cond], counts[cond]) \n",
    "        for cond in ['1',\n",
    "                     '2']\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def saddle_strength_AB(S, C): \n",
    "    \"\"\"\n",
    "    Parameters\n",
    "    ----------\n",
    "    S, C : 2D arrays, square, same shape\n",
    "        Saddle sums and counts, respectively\n",
    "        \n",
    "    Returns\n",
    "    -------\n",
    "    2x1D array\n",
    "    Ratios of cumulative corner interaction scores, where the saddle data is \n",
    "    separately AA/AB and BB/BA corners with increasing extent\n",
    "    \n",
    "    \"\"\"\n",
    "    m, n = S.shape\n",
    "    if m != n:\n",
    "        raise ValueError(\"`saddledata` should be square.\")\n",
    "\n",
    "    ratiosA = np.zeros(n)\n",
    "    for k in range(0, n):\n",
    "        intra_sumA = S[n-k:n, n-k:n].sum() \n",
    "        intra_countA = C[n-k:n, n-k:n].sum()\n",
    "        intraA = intra_sumA / intra_countA\n",
    "        \n",
    "        inter_sum = S[0:k, n-k:n].sum() + S[n-k:n, 0:k].sum()\n",
    "        inter_count =  C[0:k, n-k:n].sum() + C[n-k:n, 0:k].sum()\n",
    "        inter = inter_sum / inter_count #Don't need divide AB + BA by 2 since ratio and cancels out \n",
    "        \n",
    "        ratiosA[k] = intraA / inter\n",
    "        \n",
    "    ratiosB = np.zeros(n)\n",
    "    for k in range(0, n):\n",
    "        intra_sumB = S[0:k, 0:k].sum()\n",
    "        intra_countB = C[0:k, 0:k].sum()\n",
    "        intraB = intra_sumB / intra_countB\n",
    "        \n",
    "        inter_sum = S[0:k, n-k:n].sum() + S[n-k:n, 0:k].sum()\n",
    "        inter_count =  C[0:k, n-k:n].sum() + C[n-k:n, 0:k].sum()\n",
    "        inter = inter_sum / inter_count\n",
    "        \n",
    "        ratiosB[k] = intraB / inter\n",
    "    \n",
    "    ratios = {\n",
    "        'A' : ratiosA,\n",
    "        'B' : ratiosB\n",
    "    }\n",
    "    \n",
    "    return ratios\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/as38w/miniconda3/envs/coolerenv_manual_master/lib/python3.7/site-packages/ipykernel_launcher.py:23: RuntimeWarning: invalid value encountered in double_scalars\n",
      "/home/as38w/miniconda3/envs/coolerenv_manual_master/lib/python3.7/site-packages/ipykernel_launcher.py:27: RuntimeWarning: invalid value encountered in double_scalars\n",
      "/home/as38w/miniconda3/envs/coolerenv_manual_master/lib/python3.7/site-packages/ipykernel_launcher.py:35: RuntimeWarning: invalid value encountered in double_scalars\n",
      "/home/as38w/miniconda3/envs/coolerenv_manual_master/lib/python3.7/site-packages/ipykernel_launcher.py:39: RuntimeWarning: invalid value encountered in double_scalars\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'MEF-4OHT-dmso')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "strengthAB = {\n",
    "    cond: saddle_strength_AB(sums[cond], counts[cond]) \n",
    "        for cond in ['1',\n",
    "                     '2']\n",
    "}\n",
    "\n",
    "#hist for A\n",
    "y1=strengthAB['1']['A'][2:][::-1]\n",
    "y1[np.isnan(y1)] = 0\n",
    "y1 = np.insert(y1, 29,0)\n",
    "\n",
    "y2=strengthAB['2']['A'][2:][::-1]\n",
    "y2[np.isnan(y2)] = 0\n",
    "y2 = np.insert(y2, 29,0)\n",
    "\n",
    "#hist for B\n",
    "z1=strengthAB['1']['B'][2:]\n",
    "z1[np.isnan(z1)] = 0\n",
    "\n",
    "z2=strengthAB['2']['B'][2:]\n",
    "z2[np.isnan(z2)] = 0\n",
    "\n",
    "\n",
    "#PLOTTING\n",
    "gs = plt.GridSpec(nrows=1, ncols=2, width_ratios=[20] * len(conditions))\n",
    "plt.figure(figsize=(16,5))\n",
    "\n",
    "x = np.arange(histbins)\n",
    "\n",
    "plt.subplot(gs[0])\n",
    "plt.bar(x[:29], z1, color='goldenrod', alpha=0.8, width=1, edgecolor=\"k\")\n",
    "plt.bar(x[0:], y1, color='gold', alpha=0.8, width=1, edgecolor=\"k\", zorder=10)\n",
    "plt.axhline(5, c='grey', ls='--', lw=1, alpha=0.6)\n",
    "plt.axhline(7.5, c='grey', ls=':', lw=1, alpha=0.6)\n",
    "plt.axhline(10, c='grey', ls='--', lw=1, alpha=0.6)\n",
    "plt.axhline(15, c='grey', ls='--', lw=1, alpha=0.6)\n",
    "#plt.annotate(xy=(31,2.5), text=\"2.5\")\n",
    "plt.annotate(xy=(31,5), text=\"5\",zorder=1)\n",
    "plt.annotate(xy=(31,10), text=\"10\", zorder=1)\n",
    "plt.annotate(xy=(31,15), text=\"15\", zorder=1)\n",
    "plt.axhspan(0, 5, alpha=0.025, color='grey',zorder=1)\n",
    "plt.axhspan(5, 10, alpha=0.05, color='grey',zorder=1)\n",
    "plt.axhspan(10, 15, alpha=0.1, color='grey',zorder=1)\n",
    "plt.axhspan(15, 20, alpha=0.15, color='grey',zorder=1)\n",
    "plt.ylim((-1,17))\n",
    "plt.xlim((-1,29))\n",
    "#plt.xticks(color='w')\n",
    "plt.gca().axison = False\n",
    "plt.title('MEF-ND-dmso')\n",
    "\n",
    "plt.subplot(gs[1])\n",
    "plt.bar(x[:29], z2, color='goldenrod', alpha=0.8, width=1, edgecolor=\"k\")\n",
    "plt.bar(x[0:], y2, color='gold', alpha=0.8, width=1, edgecolor=\"k\", zorder=10)\n",
    "plt.axhline(5, c='grey', ls='--', lw=1, alpha=0.6)\n",
    "plt.axhline(7.5, c='grey', ls=':', lw=1, alpha=0.6)\n",
    "plt.axhline(10, c='grey', ls='--', lw=1, alpha=0.6)\n",
    "plt.axhline(15, c='grey', ls='--', lw=1, alpha=0.6)\n",
    "#plt.annotate(xy=(31,2.5), text=\"2.5\")\n",
    "plt.annotate(xy=(31,5), text=\"5\",zorder=1)\n",
    "plt.annotate(xy=(31,10), text=\"10\", zorder=1)\n",
    "plt.annotate(xy=(31,15), text=\"15\", zorder=1)\n",
    "plt.axhspan(0, 5, alpha=0.025, color='grey',zorder=1)\n",
    "plt.axhspan(5, 10, alpha=0.05, color='grey',zorder=1)\n",
    "plt.axhspan(10, 15, alpha=0.1, color='grey',zorder=1)\n",
    "plt.axhspan(15, 20, alpha=0.15, color='grey',zorder=1)\n",
    "plt.ylim((-1,17))\n",
    "plt.xlim((-1,29))\n",
    "plt.gca().axison = False\n",
    "plt.title('MEF-4OHT-dmso')\n",
    "\n",
    "#plt.savefig(\"*.pdf\", bbox_inches='tight')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'1': 7.337197777468752, '2': 8.750949792933065}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sB={}\n",
    "for cond in conditions:\n",
    "        sB0=strengthAB[cond]['B'][2:8]\n",
    "        sB0[np.isnan(sB0)] = 0\n",
    "        sB0=np.sum(sB0[:])/6\n",
    "        sB[cond]=sB0\n",
    "sB\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'1': 5.352202593798331, '2': 5.14860732910453}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sA={}\n",
    "for cond in conditions:\n",
    "        sA0=strengthAB[cond]['A'][2:8]\n",
    "        sA0[np.isnan(sA0)] = 0\n",
    "        sA0=np.sum(sA0[:])/6\n",
    "        sA[cond]=sA0\n",
    "sA\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# compartment flips"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>chrom</th>\n",
       "      <th>start</th>\n",
       "      <th>end</th>\n",
       "      <th>E1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>chr1</td>\n",
       "      <td>3000000</td>\n",
       "      <td>3250000</td>\n",
       "      <td>-0.890481</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>chr1</td>\n",
       "      <td>3250000</td>\n",
       "      <td>3500000</td>\n",
       "      <td>-1.184488</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>chr1</td>\n",
       "      <td>3500000</td>\n",
       "      <td>3750000</td>\n",
       "      <td>-1.221217</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>chr1</td>\n",
       "      <td>3750000</td>\n",
       "      <td>4000000</td>\n",
       "      <td>-1.080466</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>chr1</td>\n",
       "      <td>4000000</td>\n",
       "      <td>4250000</td>\n",
       "      <td>-1.012384</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   chrom    start      end        E1\n",
       "12  chr1  3000000  3250000 -0.890481\n",
       "13  chr1  3250000  3500000 -1.184488\n",
       "14  chr1  3500000  3750000 -1.221217\n",
       "15  chr1  3750000  4000000 -1.080466\n",
       "16  chr1  4000000  4250000 -1.012384"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eig1=pd.read_csv('/nl/umw_job_dekker/users/as38w/JZ2022_git/coolers/JZ-MEF-AsiS1-ND-dmso6h-HiCD2R1.mm10.250000.compcall.cis.vecs.tsv',sep='\\t')\n",
    "eig1=eig1[['chrom','start','end','E1']].dropna()\n",
    "eig2=pd.read_csv('/nl/umw_job_dekker/users/as38w/JZ2022_git/coolers/JZ-MEF-AsiS1-4OHT-dmso6h-HiCD2R1.mm10.250000.compcall.cis.vecs.tsv',sep='\\t')\n",
    "eig2=eig2[['chrom','start','end','E1']].dropna()\n",
    "eig1.head()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10245 5454 4791\n",
      "10222 6100 4122\n"
     ]
    }
   ],
   "source": [
    "eig1_tota=eig1[(eig1['E1']>0)]\n",
    "eig1_totb=eig1[(eig1['E1']<0)]\n",
    "eig2_tota=eig2[(eig2['E1']>0)]\n",
    "eig2_totb=eig2[(eig2['E1']<0)]\n",
    "print(len(eig1), len(eig1_tota),len(eig1_totb))\n",
    "#10245 5454 4791\n",
    "print(len(eig2), len(eig2_tota),len(eig2_totb))\n",
    "#10222 6100 4122\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     #A    #B    tot        pA\n",
      "0  5454  4791  10245  0.532357\n",
      "1  6100  4122  10222  0.596752\n"
     ]
    }
   ],
   "source": [
    "bins_250cis_dict = {'#A': [5454,6100], '#B': [4791,4122]}\n",
    "bins_250cis = pd.DataFrame(data=bins_250cis_dict)\n",
    "bins_250cis['tot']=bins_250cis['#A']+bins_250cis['#B']\n",
    "bins_250cis['pA']=bins_250cis['#A']/bins_250cis['tot']\n",
    "print(bins_250cis)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x108 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "A=bins_250cis['pA']*100\n",
    "B=(1-bins_250cis['pA'])*100\n",
    "labels=['ND-DMSO-R1', '4OHT-DMSO-R1']\n",
    "width=0.8\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(6,1.5))\n",
    "\n",
    "ax.barh(labels, A, width, label='A compartment', edgecolor='k', color='#fe0002', alpha=0.7)\n",
    "ax.barh(labels, B, width, label='B compartment', left=A, edgecolor='k', color='#021bf9', alpha=0.7)\n",
    "\n",
    "ax.set_xlabel('% bins @250kb')\n",
    "ax.invert_yaxis()  # labels read top-to-bottom\n",
    "ax.legend(loc='upper left')\n",
    "ax.set_xlim(0,100)\n",
    "plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.)\n",
    "plt.axvline(50, c='white', lw=1, ls='--')\n",
    "ax.set_facecolor(\"gainsboro\")\n",
    "\n",
    "fig.tight_layout()\n",
    "#plt.savefig('*.pdf', dpi=300, bbox_inches='tight')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "86 738 5454 4791\n"
     ]
    }
   ],
   "source": [
    "#4OHTvND\n",
    "eig1['eig2']=eig2['E1']\n",
    "eig1_bta=eig1[(eig1['E1']<0) & (eig1['eig2']>0)]\n",
    "eig1_atb=eig1[(eig1['E1']>0) & (eig1['eig2']<0)]\n",
    "eig1_tota=eig1[(eig1['E1']>0)]\n",
    "eig1_totb=eig1[(eig1['E1']<0)]\n",
    "\n",
    "print(len(eig1_atb),len(eig1_bta),len(eig1_tota),len(eig1_totb))\n",
    "#86 738 5454 4791\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 198x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "atb=[(86/5454)*100]\n",
    "bta=[(738/4791)*100]\n",
    "labels=['DMSO']\n",
    "\n",
    "x = np.arange(len(labels))\n",
    "width = 0.2 # the width of the bars\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(2.75,4), facecolor='white')\n",
    "rects1 = ax.bar(x - width/2, atb, width, color='white', alpha=1, edgecolor='white',zorder=5)\n",
    "rects2 = ax.bar(x + width/2, bta, width, color='white', alpha=1, edgecolor='white', zorder=5)\n",
    "\n",
    "rects1 = ax.bar(x - width/2, atb, width, label='A to B', color='#021bf9', alpha=0.7, edgecolor='k',zorder=10)\n",
    "rects2 = ax.bar(x + width/2, bta, width, label='B to A', color='#fe0002', alpha=0.7, edgecolor='k', zorder=10)\n",
    "\n",
    "\n",
    "ax.set_ylabel('% of bins flipped \\n(4OHT vs ND)')\n",
    "ax.set_title('Bin flips (250kb)', pad=20)\n",
    "ax.set_xticks(x)\n",
    "ax.set_yticks([5,10,15])\n",
    "ax.set_xticklabels(labels, rotation='45', ha='right', rotation_mode=\"anchor\")\n",
    "ax.legend()\n",
    "ax.grid(which='major', axis='y', zorder=0, color='white',linestyle='--')\n",
    "ax.set_facecolor(\"gainsboro\")\n",
    "plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.)\n",
    "plt.ylim((0,17))\n",
    "\n",
    "fig.tight_layout()\n",
    "#plt.savefig('*.pdf', dpi = 300, bbox_inches='tight')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "#comparing 1 and 2\n",
    "eig1['eig2_E1']=eig2['E1']\n",
    "#absolute differences\n",
    "eig1['abs_d1_2'] = abs(eig1['E1']-eig1['eig2_E1'])\n",
    "#adding direction of change\n",
    "eig1.loc[(eig1['E1']<eig1['eig2_E1']), 'sign_d1_2'] = '+'\n",
    "eig1.loc[(eig1['E1']>eig1['eig2_E1']), 'sign_d1_2'] = '-'\n",
    "eig1['d1_2']=eig1['sign_d1_2']+eig1['abs_d1_2'].astype(str)\n",
    "eig1['d1_2']=eig1['d1_2'].fillna(0)\n",
    "eig1['d1_2']=eig1['d1_2'].astype(float)\n",
    "eig1_a=eig1[eig1['E1']>0]\n",
    "eig1_b=eig1[eig1['E1']<0]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "eig1.loc[(eig1['eig2_E1']<0), 'colour'] = 'E1 <0 +4OHT'\n",
    "eig1.loc[(eig1['eig2_E1']>0), 'colour'] = 'E1 >0 +4OHT'\n",
    "\n",
    "diff_df = pd.DataFrame()\n",
    "diff=(eig1['d1_2'])\n",
    "diff = np.array(diff).ravel()\n",
    "diff_df['E1change'] = diff.tolist()\n",
    "\n",
    "E1_1=eig1['E1']\n",
    "diff_df['E1']=E1_1.tolist()\n",
    "colour=eig1['colour']\n",
    "diff_df['colour']=colour.tolist()\n",
    "\n",
    "bins=pd.IntervalIndex.from_tuples([(-2.2,-2),(-2, -1.8), (-1.8, -1.6), (-1.6, -1.4), (-1.4, -1.2), (-1.2, -1),(-1, -0.8), (-0.8, -0.6), (-0.6, -0.4), (-0.4, -0.2), (-0.2, 0), (0, 0.2),(0.2, 0.4),(0.4, 0.6),(0.6, 0.8), (0.8, 1),(1, 1.2),(1.2, 1.4),(1.4, 1.6),(1.6, 1.8), (1.8, 2)])\n",
    "diff_df['bin'] = pd.cut(diff_df['E1'], bins)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "diff_df=diff_df[(diff_df['E1change']<=1.75) & (diff_df['E1change']>=-1.75)&(diff_df['E1']<=1.8)&(diff_df['E1']>=-1.8)]\n",
    "\n",
    "green_diamond = dict(markerfacecolor='black', marker='o',markersize=1,markeredgecolor='none', linewidth=0, alpha=0)\n",
    "\n",
    "fig, ax1 = plt.subplots(nrows=1, ncols=1, figsize=(8, 5))\n",
    "\n",
    "ax1=sns.stripplot(x='bin', y='E1change', data=diff_df,hue='colour',palette=['#021bf9','#fe0002'], size=1.5,alpha=0.9, linewidth=0,dodge=False,jitter=0.25, marker=\"o\")\n",
    "ax1.axhline(y=0, color='grey', linewidth=1.0, linestyle='--')\n",
    "ax1.axvline(x=10.5, color='grey', linewidth=1.0, linestyle='--')\n",
    "ax1.axvspan(0,10.5, color = \"cornflowerblue\", alpha=0.08,zorder=0)\n",
    "ax1.axvspan(10.5,18, color = \"tomato\", alpha=0.08,zorder=0)\n",
    "ax1.set(ylim=(-0.55,0.55))\n",
    "ax1.set(xlim=(4.5,15.5))\n",
    "ax1.set_xticklabels(labels= (' ', ' ', '-1.8:-1.6','-1.6:-1.4','-1.4:-1.2','-{1.2-1}','-{1-0.8}', '-{0.8-0.6}', '-{0.6-0.4}','-{0.4-0.2}','-{0.2-0}','0:0.2','0.2:0.4','0.4:0.6', '0.6:0.8', '0.8:1.0', '1.0:1.2', ' ', ' ', '1.6:1.8','2'),\n",
    "                    rotation = 90,ha='center')\n",
    "plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.)\n",
    "ax1.set_xlabel('E1 : ND bins',labelpad=15)\n",
    "ax1.set_ylabel(r'$\\Delta$ E1 (4OHT - ND)',labelpad=10)\n",
    "ax1.grid(color='white', linewidth=1)\n",
    "\n",
    "fig.tight_layout()\n",
    "#plt.savefig('*.pdf', dpi = 300, bbox_inches='tight')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}