{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "from __future__ import division, print_function\n",
    "import numpy as np\n",
    "import matplotlib as mpl\n",
    "from matplotlib import pyplot as plt\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import scipy\n",
    "from statsmodels.nonparametric.smoothers_lowess import lowess\n",
    "from scipy.stats import zscore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "sns.set_style('whitegrid')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "TAD_FILE = \"../DATA/tads_new.csv\"\n",
    "res = 5000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/agalicina/anaconda3/envs/distiller-editable/lib/python3.6/site-packages/ipykernel_launcher.py:1: FutureWarning: from_csv is deprecated. Please use read_csv(...) instead. Note that some of the default arguments are different, so please refer to the documentation for from_csv when changing your function calls\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    }
   ],
   "source": [
    "df_tad = pd.DataFrame.from_csv(TAD_FILE, sep=',', header=0, index_col=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_tad.loc[:,\"bgn\"] = df_tad.start #//res\n",
    "df_tad.loc[:,\"end\"] = df_tad.end-res #//res\n",
    "df_tad.loc[:,\"ch\"] = df_tad.seqnames #.apply(lambda x: x[3:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "chrms = np.unique(df_tad.ch)\n",
    "df_tad['length'] = df_tad.end-df_tad.bgn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "filenames_full = '''BEAF_32.E0_14.narrowPeak.bedgraph  CTCF.E0_16.narrowPeak.bedgraph  M1BP.E0_24.narrowPeak.bedgraph'''.split()\n",
    "\n",
    "filenames = ['_'.join(x.split('_')[0:-1]) for x in filenames_full]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['BEAF_32.E0', 'CTCF.E0', 'M1BP.E0']"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "filenames"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/agalicina/anaconda3/envs/distiller-editable/lib/python3.6/site-packages/ipykernel_launcher.py:4: ParserWarning: Falling back to the 'python' engine because the 'c' engine does not support regex separators (separators > 1 char and different from '\\s+' are interpreted as regex); you can avoid this warning by specifying engine='python'.\n",
      "  after removing the cwd from sys.path.\n",
      "/home/agalicina/anaconda3/envs/distiller-editable/lib/python3.6/site-packages/ipykernel_launcher.py:7: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version\n",
      "of pandas will change to not sort by default.\n",
      "\n",
      "To accept the future behavior, pass 'sort=False'.\n",
      "\n",
      "To retain the current behavior and silence the warning, pass 'sort=True'.\n",
      "\n",
      "  import sys\n"
     ]
    }
   ],
   "source": [
    "df_log = pd.DataFrame({x:[] for x in ['ch', 'bgn', 'end', 'val']})\n",
    "for mode, full_mode in zip(filenames, filenames_full):\n",
    "    DATA_FILE = \"../DATA/PROFILES/{}\".format(full_mode)\n",
    "    df_tmp = pd.read_csv(DATA_FILE, sep='\\s', header=None, index_col=None, skiprows=0)\n",
    "    df_tmp.columns = ['ch', 'bgn', 'end', 'val']\n",
    "    df_tmp['m'] = mode\n",
    "    df_log = pd.concat([df_log, df_tmp])\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/agalicina/anaconda3/envs/distiller-editable/lib/python3.6/site-packages/ipykernel_launcher.py:20: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version\n",
      "of pandas will change to not sort by default.\n",
      "\n",
      "To accept the future behavior, pass 'sort=False'.\n",
      "\n",
      "To retain the current behavior and silence the warning, pass 'sort=True'.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "### Filling interTADs\n",
    "df_tad['annot'] = 't'\n",
    "df_full = pd.DataFrame(columns=df_tad.columns)\n",
    "\n",
    "for ch in chrms:\n",
    "    cond = (df_tad.ch==ch)\n",
    "    small_df = df_tad[cond]\n",
    "    small_df = small_df.sort_values('bgn').reset_index(drop=True)\n",
    "    small_df.bgn = small_df.bgn\n",
    "    small_df.end = small_df.end\n",
    "\n",
    "    s  = small_df.bgn.values\n",
    "    s1 = small_df.end.values[:-1]\n",
    "    s2 = s[1:]\n",
    "    df_tmp = pd.DataFrame({'bgn':s1, 'end':s2})\n",
    "    df_tmp['length'] = df_tmp.end-df_tmp.bgn\n",
    "    df_tmp['annot'] = 'i'\n",
    "    df_tmp = df_tmp[df_tmp.bgn!=df_tmp.end]\n",
    "    df_tmp['ch'] = ch\n",
    "    df_full = pd.concat([df_full, small_df, df_tmp])\n",
    "    \n",
    "df_full['mid'] = df_full.bgn+(df_full.end-df_full.bgn)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Creating halfs of TADs (left and right)\n",
    "\n",
    "df_new = df_full.copy(deep=True)\n",
    "df_new.annot = 'l'+df_new.annot\n",
    "df_new.end = df_new.mid\n",
    "\n",
    "df_tmp = df_full.copy(deep=True)\n",
    "df_tmp.annot = 'r'+df_tmp.annot\n",
    "df_tmp.bgn = df_tmp.mid\n",
    "\n",
    "df_new = pd.concat([df_new, df_tmp]).reset_index(drop=True)\n",
    "df_new = df_new.drop('mid', axis=1)\n",
    "\n",
    "df_new = df_new.sort_values(['ch', 'bgn']).reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "#df_full['mid'] = df_full.bgn+(df_full.end-df_full.bgn)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "chr2L\n",
      "chr2R\n",
      "chr3L\n",
      "chr3R\n",
      "chrX\n"
     ]
    }
   ],
   "source": [
    "# for each data bin we assign left and right boundary of half-tads\n",
    "\n",
    "for ch in chrms:\n",
    "    print(ch)\n",
    "    mask  = df_new.ch==ch\n",
    "    mask1 = df_log.ch==ch\n",
    "    idx = np.digitize(df_log[mask1].bgn, df_new[mask].bgn) \n",
    "    df_log.loc[mask1, 'struct'] = np.concatenate([[np.nan], df_new[mask].annot.values])[idx]\n",
    "    df_log.loc[mask1, 'tad_bgn'] = np.concatenate([[np.nan], df_new[mask].bgn.values])[idx]\n",
    "    df_log.loc[mask1, 'tad_end'] = np.concatenate([[np.nan], df_new[mask].end.values])[idx]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "df_log['dist_to_start'] = df_log.bgn - df_log.tad_bgn\n",
    "df_log['dist_to_end']   = df_log.tad_end - df_log.bgn "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "df_log = df_log.replace([np.inf, -np.inf], np.nan)\n",
    "df_log = df_log.dropna().reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BEAF_32.E0\n",
      "CTCF.E0\n",
      "M1BP.E0\n"
     ]
    }
   ],
   "source": [
    "for mode in filenames:\n",
    "    print(mode)\n",
    "    mask = (df_log.m == mode)\n",
    "    df_log.loc[mask, 'z_val'] = df_log.loc[mask,'val'] #zscore(df_log.loc[mask,'val'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/agalicina/anaconda3/envs/distiller-editable/lib/python3.6/site-packages/ipykernel_launcher.py:32: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version\n",
      "of pandas will change to not sort by default.\n",
      "\n",
      "To accept the future behavior, pass 'sort=False'.\n",
      "\n",
      "To retain the current behavior and silence the warning, pass 'sort=True'.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "toplot_all = pd.DataFrame(columns=[u'std_z', u'z', 'bins', 'm'])\n",
    "\n",
    "for mode in filenames:\n",
    "    \n",
    "    rng = [-1e5, 1e5, 5e3]\n",
    "\n",
    "    mean_z, std_z, counts, all_bins = [np.empty(0), np.empty(0), np.empty(0), np.empty(0)]\n",
    "\n",
    "    for struct in ['rt', 'lt', 'ri', 'li']:\n",
    "        df_tmp = df_log[(df_log.m==mode)&(df_log.struct==struct)].reset_index(drop=True)\n",
    "        bins = np.arange(0, rng[1], rng[2])\n",
    "        if 'r' in struct:\n",
    "            groups = df_tmp.groupby(np.digitize(df_tmp.dist_to_end, bins))\n",
    "        else:\n",
    "            groups = df_tmp.groupby(np.digitize(df_tmp.dist_to_start, bins))\n",
    "\n",
    "        mean_z_tmp = groups.mean().z_val.values\n",
    "        \n",
    "        std_z_tmp  = groups.count().z_val.values\n",
    "\n",
    "        if 'i' in struct:\n",
    "            bins = -bins-rng[2] ### !!!\n",
    "\n",
    "        mean_z = np.concatenate([mean_z, mean_z_tmp])\n",
    "        std_z  = np.concatenate([std_z,  std_z_tmp])\n",
    "        all_bins = np.concatenate([all_bins, np.concatenate([[np.nan], bins])[groups.mean().index]] )\n",
    "\n",
    "    toplot = pd.DataFrame({'bins': all_bins, 'z': mean_z, 'std_z': std_z}).groupby('bins').mean()\n",
    "    toplot['m'] = mode\n",
    "    toplot['bins'] = toplot.index\n",
    "    \n",
    "    toplot_all = pd.concat([toplot_all, toplot]).reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "colors = ['#FCF128', \n",
    "          '#FCF128', \n",
    "          '#006CC3', \n",
    "          '#006CC3', \n",
    "          '#D05836', \n",
    "          '#89A4D4', \n",
    "          '#737F86', \n",
    "          '#006CC3', \n",
    "          '#D05836', \n",
    "          '#D05836',\n",
    "          '#89A4D4', \n",
    "          '#737F86', \n",
    "          '#FCF128'\n",
    "         ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "col_dict = {filenames[i]:colors[i] for i in range(len(filenames))}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "from scipy.interpolate import interp1d\n",
    "\n",
    "def plot_lines_multi(toplot, rng, filenames=None, colors=None, names=None):\n",
    "    plt.figure(figsize=(8,5))\n",
    "    plt.xlim(rng[0], rng[1])\n",
    "    plt.title('InterTAD -> TAD')\n",
    "    plt.xticks(np.arange(rng[0], rng[1], rng[2]))\n",
    "    for i, mode in enumerate(filenames):\n",
    "        mask = toplot.m==mode\n",
    "        filtered = lowess(zscore(toplot.loc[mask,'z']), toplot.loc[mask,'bins'], is_sorted=False, frac=0.2, it=3)\n",
    "        plt.plot( filtered[:,0], filtered[:,1], colors[i], label=names[i], linewidth=2)\n",
    "    plt.legend()\n",
    "    \n",
    "def plot_lines_multi_calc_z(toplot_initial, rng, filenames=None, colors=None, names=None, smooth=True):\n",
    "    toplot = toplot_initial.loc[np.in1d(toplot_initial.bins, np.arange(*rng)),:].copy()\n",
    "    plt.figure(figsize=(10,7))\n",
    "    plt.xlim(rng[0], rng[1])\n",
    "    plt.title('InterTAD -> TAD')\n",
    "    plt.xticks(np.arange(rng[0], rng[1], rng[2]))\n",
    "    for i, mode in enumerate(filenames):\n",
    "        mask = (toplot.m==mode)\n",
    "        vals = toplot.loc[mask, 'z']\n",
    "        if smooth:\n",
    "            filtered = lowess(vals, toplot.loc[mask,'bins'], is_sorted=False, frac=0.3, it=6)\n",
    "\n",
    "            f = interp1d(filtered[:,0], filtered[:,1], bounds_error=False, kind='cubic')\n",
    "            xnew = np.arange(rng[0], rng[1], (rng[1]-rng[0])/1000)\n",
    "            ynew = f(xnew)\n",
    "            \n",
    "            plt.plot( xnew, ynew, colors[i], label=names[i], linewidth=2)\n",
    "            plt.scatter(toplot.loc[mask,'bins'], vals, s=80, \n",
    "                        marker='o', lw=1.3, facecolors='none', edgecolors=colors[i])\n",
    "        else:\n",
    "            sns.regplot(x=toplot.loc[mask,'bins'], y=zscore(toplot.loc[mask,'z']),\n",
    "                        scatter_kws={\"s\": 40, \"marker\": \"o\"}, label=names[i], lowess=True, #order=5, # # \n",
    "                        color=colors[i], ci=None)\n",
    "        plt.xticks(rotation=70)\n",
    "    plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "filenames_tmp = filenames\n",
    "names_tmp = filenames\n",
    "colors_tmp = ['#82D3BD', '#00A679', '#BEB5DB']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_lines_multi_calc_z(toplot_all, [-35000, 5e4, 5e3], \n",
    "                 filenames=filenames_tmp, \n",
    "                 colors=colors_tmp,\n",
    "                names=names_tmp, \n",
    "                smooth=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_lines_multi(toplot_all, [-35000, 5e4, 5e3], \n",
    "                 filenames=filenames_tmp, \n",
    "                 colors=colors_tmp,\n",
    "                names=names_tmp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (distiller-editable)",
   "language": "python",
   "name": "distiller-editable"
  },
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}