{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Inline graphing\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Import packages\n",
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import matplotlib.patches as mpat\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.manifold import MDS\n",
    "from scipy.spatial.distance import cdist \n",
    "from statistics import median, mean, variance\n",
    "from scipy.stats import ttest_ind\n",
    "from scipy.cluster import hierarchy as hc\n",
    "from math import sqrt, log10\n",
    "\n",
    "import matplotlib.image as mpimg\n",
    "\n",
    "from matplotlib.path import Path\n",
    "from matplotlib.spines import Spine\n",
    "from matplotlib.projections.polar import PolarAxes\n",
    "from matplotlib.projections import register_projection\n",
    "from operator import sub, add"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Set working directory to wild-type 1 folder\n",
    "os.chdir('C:/Users/ooma1/OneDrive - UC San Diego/Guatelli Lab/Cell Fractionation/20190308 Jurkat TREHIV WT fract MS/')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Reading in full data for first wild-type experiment\n",
    "wua1 = pd.read_csv('UnA/rowsum/20190516_UnA_RowSum.csv', index_col=0)\n",
    "wub1 = pd.read_csv('UnB/rowsum/20190516_UnB_RowSum.csv', index_col=0)\n",
    "wuc1 = pd.read_csv('UnC/rowsum/20190516_UnC_RowSum.csv', index_col=0)\n",
    "\n",
    "wia1 = pd.read_csv('IndA/rowsum/20190516_IndA_RowSum.csv', index_col=0)\n",
    "wib1 = pd.read_csv('IndB/rowsum/20190516_IndB_RowSum.csv', index_col=0)\n",
    "wic1 = pd.read_csv('IndC/rowsum/20190516_IndC_RowSum.csv', index_col=0)\n",
    "\n",
    "wm1 = pd.read_csv('IndA/ExpandedMarkerSet_ItzWithEnhCommon_OutliersRemoved_rowsum.csv')\n",
    "wm1.columns = ['Protein', 'Compartment']\n",
    "wm1.set_index('Protein', inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Set working directory to wild-type 2 folder\n",
    "os.chdir('C:/Users/ooma1/OneDrive - UC San Diego/Guatelli Lab/Cell Fractionation/20190517 Jurkat TREHIV WT fract MS/')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Reading in full data for second wild-type experiment\n",
    "wua2 = pd.read_csv('UnA/20190517_UnA_RowSum.csv', index_col=0)\n",
    "wub2 = pd.read_csv('UnB/20190517_UnB_RowSum.csv', index_col=0)\n",
    "wuc2 = pd.read_csv('UnC/20190517_UnC_RowSum.csv', index_col=0)\n",
    "\n",
    "wia2 = pd.read_csv('IndA/20190517_IndA_RowSum.csv', index_col=0)\n",
    "wib2 = pd.read_csv('IndB/20190517_IndB_RowSum.csv', index_col=0)\n",
    "wic2 = pd.read_csv('IndC/20190517_IndC_RowSum.csv', index_col=0)\n",
    "\n",
    "wm2 = pd.read_csv('IndA/ExpandedMarkerSet_ItzWithEnhCommon_OutliersRemoved.csv')\n",
    "wm2.columns = ['Protein', 'Compartment']\n",
    "wm2.set_index('Protein', inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Changing columns to replicate invariant names\n",
    "wua1.columns = ['Gene', 'Protein information', '3K', '5.4K', '12.2K', '24K', '78.4K', '110K', '195.5K']\n",
    "wub1.columns = ['Gene', 'Protein information', '3K', '5.4K', '12.2K', '24K', '78.4K', '110K', '195.5K']\n",
    "wuc1.columns = ['Gene', 'Protein information', '3K', '5.4K', '12.2K', '24K', '78.4K', '110K', '195.5K']\n",
    "wia1.columns = ['Gene', 'Protein information', '3K', '5.4K', '12.2K', '24K', '78.4K', '110K', '195.5K']\n",
    "wib1.columns = ['Gene', 'Protein information', '3K', '5.4K', '12.2K', '24K', '78.4K', '110K', '195.5K']\n",
    "wic1.columns = ['Gene', 'Protein information', '3K', '5.4K', '12.2K', '24K', '78.4K', '110K', '195.5K']\n",
    "\n",
    "wua2.columns = ['Gene', 'Protein information', '3K', '5.4K', '12.2K', '24K', '78.4K', '110K', '195.5K']\n",
    "wub2.columns = ['Gene', 'Protein information', '3K', '5.4K', '12.2K', '24K', '78.4K', '110K', '195.5K']\n",
    "wuc2.columns = ['Gene', 'Protein information', '3K', '5.4K', '12.2K', '24K', '78.4K', '110K', '195.5K']\n",
    "wia2.columns = ['Gene', 'Protein information', '3K', '5.4K', '12.2K', '24K', '78.4K', '110K', '195.5K']\n",
    "wib2.columns = ['Gene', 'Protein information', '3K', '5.4K', '12.2K', '24K', '78.4K', '110K', '195.5K']\n",
    "wic2.columns = ['Gene', 'Protein information', '3K', '5.4K', '12.2K', '24K', '78.4K', '110K', '195.5K']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Set working directory to dNef 1 folder\n",
    "os.chdir('C:/Users/ooma1/OneDrive - UC San Diego/Guatelli Lab/Cell Fractionation/20190612 Jurkat TREHIV dNef fract MS/')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Reading in full data for first dNef experiment\n",
    "dua1 = pd.read_csv('UnA/20190612_UnA_RowSum.csv', index_col=0)\n",
    "dub1 = pd.read_csv('UnB/20190612_UnB_RowSum.csv', index_col=0)\n",
    "duc1 = pd.read_csv('UnC/20190612_UnC_RowSum.csv', index_col=0)\n",
    "\n",
    "dia1 = pd.read_csv('IndA/20190612_IndA_RowSum.csv', index_col=0)\n",
    "dib1 = pd.read_csv('IndB/20190612_IndB_RowSum.csv', index_col=0)\n",
    "dic1 = pd.read_csv('IndC/20190612_IndC_RowSum.csv', index_col=0)\n",
    "\n",
    "dm1 = pd.read_csv('IndA/ExpandedMarkerSet_ItzWithEnhCommon_OutliersRemoved.csv')\n",
    "dm1.columns = ['Protein', 'Compartment']\n",
    "dm1.set_index('Protein', inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Set working directory to dNef 2 folder\n",
    "os.chdir('C:/Users/ooma1/OneDrive - UC San Diego/Guatelli Lab/Cell Fractionation/20191122 Jurkat TREHIV dNef fract MS/')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Reading in full data for second dNef experiment\n",
    "dua2 = pd.read_csv('UnA/20191122_UnA_RowSum.csv', index_col=0)\n",
    "dub2 = pd.read_csv('UnB/20191122_UnB_RowSum.csv', index_col=0)\n",
    "duc2 = pd.read_csv('UnC/20191122_UnC_RowSum.csv', index_col=0)\n",
    "\n",
    "dia2 = pd.read_csv('IndA/20191122_IndA_RowSum.csv', index_col=0)\n",
    "dib2 = pd.read_csv('IndB/20191122_IndB_RowSum.csv', index_col=0)\n",
    "dic2 = pd.read_csv('IndC/20191122_IndC_RowSum.csv', index_col=0)\n",
    "\n",
    "dm2 = pd.read_csv('IndA/ExpandedMarkerSet_ItzWithEnhCommon_OutliersRemoved.csv')\n",
    "dm2.columns = ['Protein', 'Compartment']\n",
    "dm2.set_index('Protein', inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Set working directory to folder comparing biological replicates\n",
    "os.chdir('C:/Users/ooma1/OneDrive - UC San Diego/Guatelli Lab/Cell Fractionation/FractPaperFigures')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Changing columns to replicate invariant names\n",
    "dua1.columns = ['Gene', 'Protein information', '3K', '5.4K', '12.2K', '24K', '78.4K', '110K', '195.5K']\n",
    "dub1.columns = ['Gene', 'Protein information', '3K', '5.4K', '12.2K', '24K', '78.4K', '110K', '195.5K']\n",
    "duc1.columns = ['Gene', 'Protein information', '3K', '5.4K', '12.2K', '24K', '78.4K', '110K', '195.5K']\n",
    "dia1.columns = ['Gene', 'Protein information', '3K', '5.4K', '12.2K', '24K', '78.4K', '110K', '195.5K']\n",
    "dib1.columns = ['Gene', 'Protein information', '3K', '5.4K', '12.2K', '24K', '78.4K', '110K', '195.5K']\n",
    "dic1.columns = ['Gene', 'Protein information', '3K', '5.4K', '12.2K', '24K', '78.4K', '110K', '195.5K']\n",
    "\n",
    "dua2.columns = ['Gene', 'Protein information', '3K', '5.4K', '12.2K', '24K', '78.4K', '110K', '195.5K']\n",
    "dub2.columns = ['Gene', 'Protein information', '3K', '5.4K', '12.2K', '24K', '78.4K', '110K', '195.5K']\n",
    "duc2.columns = ['Gene', 'Protein information', '3K', '5.4K', '12.2K', '24K', '78.4K', '110K', '195.5K']\n",
    "dia2.columns = ['Gene', 'Protein information', '3K', '5.4K', '12.2K', '24K', '78.4K', '110K', '195.5K']\n",
    "dib2.columns = ['Gene', 'Protein information', '3K', '5.4K', '12.2K', '24K', '78.4K', '110K', '195.5K']\n",
    "dic2.columns = ['Gene', 'Protein information', '3K', '5.4K', '12.2K', '24K', '78.4K', '110K', '195.5K']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Common Wild-type Markers:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Large Protein Complex    63\n",
       "Endosome                 25\n",
       "ER                       11\n",
       "Golgi                    10\n",
       "Plasma membrane           9\n",
       "Lysosome                  9\n",
       "Peroxisome                8\n",
       "Mitochondrion             7\n",
       "Name: Compartment, dtype: int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------\n",
      "Common dNef Markers:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Large Protein Complex    110\n",
       "Endosome                  29\n",
       "ER                        19\n",
       "Plasma membrane           13\n",
       "Golgi                     10\n",
       "Peroxisome                 9\n",
       "Lysosome                   8\n",
       "Mitochondrion              6\n",
       "Name: Compartment, dtype: int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "# Common markers for WT, dNef, and all biological replicates\n",
    "wm = pd.concat([wm1, wm2], join='inner', axis=1).iloc[:, 0:1]\n",
    "print('Common Wild-type Markers:')\n",
    "display(wm.Compartment.value_counts())\n",
    "print(50*'-')\n",
    "dm = pd.concat([dm1, dm2], join='inner', axis=1).iloc[:, 0:1]\n",
    "print('Common dNef Markers:')\n",
    "display(dm.Compartment.value_counts())\n",
    "print(50*'-')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Peroxisomes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Wild-type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculating pairwise distance matrices for WT1\n",
    "wua1_dist = pd.DataFrame(data=cdist(wua1.loc[wm.index, '3K':'195.5K'], wua1.loc[wm.index, '3K':'195.5K'], 'euclidean'), \n",
    "                         index=wm.index, columns=wm.index)\n",
    "wub1_dist = pd.DataFrame(data=cdist(wub1.loc[wm.index, '3K':'195.5K'], wub1.loc[wm.index, '3K':'195.5K'], 'euclidean'), \n",
    "                         index=wm.index, columns=wm.index)\n",
    "wuc1_dist = pd.DataFrame(data=cdist(wuc1.loc[wm.index, '3K':'195.5K'], wuc1.loc[wm.index, '3K':'195.5K'], 'euclidean'), \n",
    "                         index=wm.index, columns=wm.index)\n",
    "\n",
    "wia1_dist = pd.DataFrame(data=cdist(wia1.loc[wm.index, '3K':'195.5K'], wia1.loc[wm.index, '3K':'195.5K'], 'euclidean'), \n",
    "                         index=wm.index, columns=wm.index)\n",
    "wib1_dist = pd.DataFrame(data=cdist(wib1.loc[wm.index, '3K':'195.5K'], wib1.loc[wm.index, '3K':'195.5K'], 'euclidean'), \n",
    "                         index=wm.index, columns=wm.index)\n",
    "wic1_dist = pd.DataFrame(data=cdist(wic1.loc[wm.index, '3K':'195.5K'], wic1.loc[wm.index, '3K':'195.5K'], 'euclidean'), \n",
    "                         index=wm.index, columns=wm.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculating pairwise distance matrices for WT2\n",
    "wua2_dist = pd.DataFrame(data=cdist(wua2.loc[wm2.index, '3K':'195.5K'], wua2.loc[wm2.index, '3K':'195.5K'], 'euclidean'), \n",
    "                         index=wm2.index, columns=wm2.index)\n",
    "wub2_dist = pd.DataFrame(data=cdist(wub2.loc[wm2.index, '3K':'195.5K'], wub2.loc[wm2.index, '3K':'195.5K'], 'euclidean'), \n",
    "                         index=wm2.index, columns=wm2.index)\n",
    "wuc2_dist = pd.DataFrame(data=cdist(wuc2.loc[wm2.index, '3K':'195.5K'], wuc2.loc[wm2.index, '3K':'195.5K'], 'euclidean'), \n",
    "                         index=wm2.index, columns=wm2.index)\n",
    "\n",
    "wia2_dist = pd.DataFrame(data=cdist(wia2.loc[wm2.index, '3K':'195.5K'], wia2.loc[wm2.index, '3K':'195.5K'], 'euclidean'), \n",
    "                         index=wm2.index, columns=wm2.index)\n",
    "wib2_dist = pd.DataFrame(data=cdist(wib2.loc[wm2.index, '3K':'195.5K'], wib2.loc[wm2.index, '3K':'195.5K'], 'euclidean'), \n",
    "                         index=wm2.index, columns=wm2.index)\n",
    "wic2_dist = pd.DataFrame(data=cdist(wic2.loc[wm2.index, '3K':'195.5K'], wic2.loc[wm2.index, '3K':'195.5K'], 'euclidean'), \n",
    "                         index=wm2.index, columns=wm2.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generating lists of distances between peroxisomal proteins and other organellar proteins, wild-type uninduced\n",
    "pero_er_wu = []\n",
    "pero_endo_wu = []\n",
    "pero_gol_wu = []\n",
    "pero_lpc_wu = []\n",
    "pero_lyso_wu = []\n",
    "pero_mito_wu = []\n",
    "pero_pm_wu = []\n",
    "\n",
    "wunind_dist = [wua1_dist, wub1_dist, wuc1_dist, wua2_dist, wub2_dist, wuc2_dist]\n",
    "\n",
    "for df in wunind_dist:\n",
    "    pero_er_wu.append(df.loc[wm[wm['Compartment'] == 'Peroxisome'].index, wm[wm['Compartment'] == 'ER'].index].values.flatten().tolist())\n",
    "    pero_endo_wu.append(df.loc[wm[wm['Compartment'] == 'Peroxisome'].index, wm[wm['Compartment'] == 'Endosome'].index].values.flatten().tolist())\n",
    "    pero_gol_wu.append(df.loc[wm[wm['Compartment'] == 'Peroxisome'].index, wm[wm['Compartment'] == 'Golgi'].index].values.flatten().tolist())\n",
    "    pero_lpc_wu.append(df.loc[wm[wm['Compartment'] == 'Peroxisome'].index, wm[wm['Compartment'] == 'Large Protein Complex'].index].values.flatten().tolist())\n",
    "    pero_lyso_wu.append(df.loc[wm[wm['Compartment'] == 'Peroxisome'].index, wm[wm['Compartment'] == 'Lysosome'].index].values.flatten().tolist())\n",
    "    pero_mito_wu.append(df.loc[wm[wm['Compartment'] == 'Peroxisome'].index, wm[wm['Compartment'] == 'Mitochondrion'].index].values.flatten().tolist())\n",
    "    pero_pm_wu.append(df.loc[wm[wm['Compartment'] == 'Peroxisome'].index, wm[wm['Compartment'] == 'Plasma membrane'].index].values.flatten().tolist())\n",
    "    \n",
    "pero_er_wu = [item for sublist in pero_er_wu for item in sublist]\n",
    "pero_endo_wu = [item for sublist in pero_endo_wu for item in sublist]\n",
    "pero_gol_wu = [item for sublist in pero_gol_wu for item in sublist]\n",
    "pero_lpc_wu = [item for sublist in pero_lpc_wu for item in sublist]\n",
    "pero_lyso_wu = [item for sublist in pero_lyso_wu for item in sublist]\n",
    "pero_mito_wu = [item for sublist in pero_mito_wu for item in sublist]\n",
    "pero_pm_wu = [item for sublist in pero_pm_wu for item in sublist]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generating lists of distances between peroxisomal proteins and other organellar proteins, wild-type induced\n",
    "pero_er_wi = []\n",
    "pero_endo_wi = []\n",
    "pero_gol_wi = []\n",
    "pero_lpc_wi = []\n",
    "pero_lyso_wi = []\n",
    "pero_mito_wi = []\n",
    "pero_pm_wi = []\n",
    "\n",
    "wind_dist = [wia1_dist, wib1_dist, wic1_dist, wia2_dist, wib2_dist, wic2_dist]\n",
    "\n",
    "for df in wind_dist:\n",
    "    pero_er_wi.append(df.loc[wm[wm['Compartment'] == 'Peroxisome'].index, wm[wm['Compartment'] == 'ER'].index].values.flatten().tolist())\n",
    "    pero_endo_wi.append(df.loc[wm[wm['Compartment'] == 'Peroxisome'].index, wm[wm['Compartment'] == 'Endosome'].index].values.flatten().tolist())\n",
    "    pero_gol_wi.append(df.loc[wm[wm['Compartment'] == 'Peroxisome'].index, wm[wm['Compartment'] == 'Golgi'].index].values.flatten().tolist())\n",
    "    pero_lpc_wi.append(df.loc[wm[wm['Compartment'] == 'Peroxisome'].index, wm[wm['Compartment'] == 'Large Protein Complex'].index].values.flatten().tolist())\n",
    "    pero_lyso_wi.append(df.loc[wm[wm['Compartment'] == 'Peroxisome'].index, wm[wm['Compartment'] == 'Lysosome'].index].values.flatten().tolist())\n",
    "    pero_mito_wi.append(df.loc[wm[wm['Compartment'] == 'Peroxisome'].index, wm[wm['Compartment'] == 'Mitochondrion'].index].values.flatten().tolist())\n",
    "    pero_pm_wi.append(df.loc[wm[wm['Compartment'] == 'Peroxisome'].index, wm[wm['Compartment'] == 'Plasma membrane'].index].values.flatten().tolist())\n",
    "    \n",
    "pero_er_wi = [item for sublist in pero_er_wi for item in sublist]\n",
    "pero_endo_wi = [item for sublist in pero_endo_wi for item in sublist]\n",
    "pero_gol_wi = [item for sublist in pero_gol_wi for item in sublist]\n",
    "pero_lpc_wi = [item for sublist in pero_lpc_wi for item in sublist]\n",
    "pero_lyso_wi = [item for sublist in pero_lyso_wi for item in sublist]\n",
    "pero_mito_wi = [item for sublist in pero_mito_wi for item in sublist]\n",
    "pero_pm_wi = [item for sublist in pero_pm_wi for item in sublist]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculating mean value for each\n",
    "wunind = [pero_er_wu, pero_endo_wu, pero_gol_wu, pero_lpc_wu, pero_lyso_wu, pero_mito_wu, pero_pm_wu]\n",
    "wind = [pero_er_wi, pero_endo_wi, pero_gol_wi, pero_lpc_wi, pero_lyso_wi, pero_mito_wi, pero_pm_wi]\n",
    "\n",
    "wunind_mean = []\n",
    "wind_mean = []\n",
    "\n",
    "for unval, indval in zip(wunind, wind):\n",
    "    x1 = mean(unval)\n",
    "    wunind_mean.append(x1)\n",
    "    x2 = mean(indval)\n",
    "    wind_mean.append(x2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## dNef"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculating pairwise distance matrices for dNef1\n",
    "dua1_dist = pd.DataFrame(data=cdist(dua1.loc[dm.index, '3K':'195.5K'], dua1.loc[dm.index, '3K':'195.5K'], 'euclidean'), \n",
    "                         index=dm.index, columns=dm.index)\n",
    "dub1_dist = pd.DataFrame(data=cdist(dub1.loc[dm.index, '3K':'195.5K'], dub1.loc[dm.index, '3K':'195.5K'], 'euclidean'), \n",
    "                         index=dm.index, columns=dm.index)\n",
    "duc1_dist = pd.DataFrame(data=cdist(duc1.loc[dm.index, '3K':'195.5K'], duc1.loc[dm.index, '3K':'195.5K'], 'euclidean'), \n",
    "                         index=dm.index, columns=dm.index)\n",
    "\n",
    "dia1_dist = pd.DataFrame(data=cdist(dia1.loc[dm.index, '3K':'195.5K'], dia1.loc[dm.index, '3K':'195.5K'], 'euclidean'), \n",
    "                         index=dm.index, columns=dm.index)\n",
    "dib1_dist = pd.DataFrame(data=cdist(dib1.loc[dm.index, '3K':'195.5K'], dib1.loc[dm.index, '3K':'195.5K'], 'euclidean'), \n",
    "                         index=dm.index, columns=dm.index)\n",
    "dic1_dist = pd.DataFrame(data=cdist(dic1.loc[dm.index, '3K':'195.5K'], dic1.loc[dm.index, '3K':'195.5K'], 'euclidean'), \n",
    "                         index=dm.index, columns=dm.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculating pairwise distance matrices for dNef2\n",
    "dua2_dist = pd.DataFrame(data=cdist(dua2.loc[dm2.index, '3K':'195.5K'], dua2.loc[dm2.index, '3K':'195.5K'], 'euclidean'), \n",
    "                         index=dm2.index, columns=dm2.index)\n",
    "dub2_dist = pd.DataFrame(data=cdist(dub2.loc[dm2.index, '3K':'195.5K'], dub2.loc[dm2.index, '3K':'195.5K'], 'euclidean'), \n",
    "                         index=dm2.index, columns=dm2.index)\n",
    "duc2_dist = pd.DataFrame(data=cdist(duc2.loc[dm2.index, '3K':'195.5K'], duc2.loc[dm2.index, '3K':'195.5K'], 'euclidean'), \n",
    "                         index=dm2.index, columns=dm2.index)\n",
    "\n",
    "dia2_dist = pd.DataFrame(data=cdist(dia2.loc[dm2.index, '3K':'195.5K'], dia2.loc[dm2.index, '3K':'195.5K'], 'euclidean'), \n",
    "                         index=dm2.index, columns=dm2.index)\n",
    "dib2_dist = pd.DataFrame(data=cdist(dib2.loc[dm2.index, '3K':'195.5K'], dib2.loc[dm2.index, '3K':'195.5K'], 'euclidean'), \n",
    "                         index=dm2.index, columns=dm2.index)\n",
    "dic2_dist = pd.DataFrame(data=cdist(dic2.loc[dm2.index, '3K':'195.5K'], dic2.loc[dm2.index, '3K':'195.5K'], 'euclidean'), \n",
    "                         index=dm2.index, columns=dm2.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generating lists of distances between peroxisomal proteins and other organellar proteins, dNef uninduced\n",
    "pero_er_du = []\n",
    "pero_endo_du = []\n",
    "pero_gol_du = []\n",
    "pero_lpc_du = []\n",
    "pero_lyso_du = []\n",
    "pero_mito_du = []\n",
    "pero_pm_du = []\n",
    "\n",
    "dunind_dist = [dua1_dist, dub1_dist, duc1_dist, dua2_dist, dub2_dist, duc2_dist]\n",
    "\n",
    "for df in dunind_dist:\n",
    "    pero_er_du.append(df.loc[dm[dm['Compartment'] == 'Peroxisome'].index, dm[dm['Compartment'] == 'ER'].index].values.flatten().tolist())\n",
    "    pero_endo_du.append(df.loc[dm[dm['Compartment'] == 'Peroxisome'].index, dm[dm['Compartment'] == 'Endosome'].index].values.flatten().tolist())\n",
    "    pero_gol_du.append(df.loc[dm[dm['Compartment'] == 'Peroxisome'].index, dm[dm['Compartment'] == 'Golgi'].index].values.flatten().tolist())\n",
    "    pero_lpc_du.append(df.loc[dm[dm['Compartment'] == 'Peroxisome'].index, dm[dm['Compartment'] == 'Large Protein Complex'].index].values.flatten().tolist())\n",
    "    pero_lyso_du.append(df.loc[dm[dm['Compartment'] == 'Peroxisome'].index, dm[dm['Compartment'] == 'Lysosome'].index].values.flatten().tolist())\n",
    "    pero_mito_du.append(df.loc[dm[dm['Compartment'] == 'Peroxisome'].index, dm[dm['Compartment'] == 'Mitochondrion'].index].values.flatten().tolist())\n",
    "    pero_pm_du.append(df.loc[dm[dm['Compartment'] == 'Peroxisome'].index, dm[dm['Compartment'] == 'Plasma membrane'].index].values.flatten().tolist())\n",
    "    \n",
    "pero_er_du = [item for sublist in pero_er_du for item in sublist]\n",
    "pero_endo_du = [item for sublist in pero_endo_du for item in sublist]\n",
    "pero_gol_du = [item for sublist in pero_gol_du for item in sublist]\n",
    "pero_lpc_du = [item for sublist in pero_lpc_du for item in sublist]\n",
    "pero_lyso_du = [item for sublist in pero_lyso_du for item in sublist]\n",
    "pero_mito_du = [item for sublist in pero_mito_du for item in sublist]\n",
    "pero_pm_du = [item for sublist in pero_pm_du for item in sublist]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generating lists of distances between peroxisomal proteins and other organellar proteins, dNef induced\n",
    "pero_er_di = []\n",
    "pero_endo_di = []\n",
    "pero_gol_di = []\n",
    "pero_lpc_di = []\n",
    "pero_lyso_di = []\n",
    "pero_mito_di = []\n",
    "pero_pm_di = []\n",
    "\n",
    "dind_dist = [dia1_dist, dib1_dist, dic1_dist, dia2_dist, dib2_dist, dic2_dist]\n",
    "\n",
    "for df in dind_dist:\n",
    "    pero_er_di.append(df.loc[dm[dm['Compartment'] == 'Peroxisome'].index, dm[dm['Compartment'] == 'ER'].index].values.flatten().tolist())\n",
    "    pero_endo_di.append(df.loc[dm[dm['Compartment'] == 'Peroxisome'].index, dm[dm['Compartment'] == 'Endosome'].index].values.flatten().tolist())\n",
    "    pero_gol_di.append(df.loc[dm[dm['Compartment'] == 'Peroxisome'].index, dm[dm['Compartment'] == 'Golgi'].index].values.flatten().tolist())\n",
    "    pero_lpc_di.append(df.loc[dm[dm['Compartment'] == 'Peroxisome'].index, dm[dm['Compartment'] == 'Large Protein Complex'].index].values.flatten().tolist())\n",
    "    pero_lyso_di.append(df.loc[dm[dm['Compartment'] == 'Peroxisome'].index, dm[dm['Compartment'] == 'Lysosome'].index].values.flatten().tolist())\n",
    "    pero_mito_di.append(df.loc[dm[dm['Compartment'] == 'Peroxisome'].index, dm[dm['Compartment'] == 'Mitochondrion'].index].values.flatten().tolist())\n",
    "    pero_pm_di.append(df.loc[dm[dm['Compartment'] == 'Peroxisome'].index, dm[dm['Compartment'] == 'Plasma membrane'].index].values.flatten().tolist())\n",
    "    \n",
    "pero_er_di = [item for sublist in pero_er_di for item in sublist]\n",
    "pero_endo_di = [item for sublist in pero_endo_di for item in sublist]\n",
    "pero_gol_di = [item for sublist in pero_gol_di for item in sublist]\n",
    "pero_lpc_di = [item for sublist in pero_lpc_di for item in sublist]\n",
    "pero_lyso_di = [item for sublist in pero_lyso_di for item in sublist]\n",
    "pero_mito_di = [item for sublist in pero_mito_di for item in sublist]\n",
    "pero_pm_di = [item for sublist in pero_pm_di for item in sublist]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculating mean value for each\n",
    "dunind = [pero_er_du, pero_endo_du, pero_gol_du, pero_lpc_du, pero_lyso_du, pero_mito_du, pero_pm_du]\n",
    "dind = [pero_er_di, pero_endo_di, pero_gol_di, pero_lpc_di, pero_lyso_di, pero_mito_di, pero_pm_di]\n",
    "\n",
    "dunind_mean = []\n",
    "dind_mean = []\n",
    "\n",
    "for unval, indval in zip(dunind, dind):\n",
    "    x1 = mean(unval)\n",
    "    dunind_mean.append(x1)\n",
    "    x2 = mean(indval)\n",
    "    dind_mean.append(x2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Set working directory to figure folder\n",
    "os.chdir('C:/Users/ooma1/OneDrive - UC San Diego/Guatelli Lab/IF Experiments/20210207 Jurkat WT and dNef eGFP-SKL')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ooma1\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:13: ParserWarning: Falling back to the 'python' engine because the 'c' engine does not support sep=None with delim_whitespace=False; you can avoid this warning by specifying engine='python'.\n",
      "  del sys.path[0]\n",
      "C:\\Users\\ooma1\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:18: ParserWarning: Falling back to the 'python' engine because the 'c' engine does not support sep=None with delim_whitespace=False; you can avoid this warning by specifying engine='python'.\n",
      "C:\\Users\\ooma1\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:23: ParserWarning: Falling back to the 'python' engine because the 'c' engine does not support sep=None with delim_whitespace=False; you can avoid this warning by specifying engine='python'.\n",
      "C:\\Users\\ooma1\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:28: ParserWarning: Falling back to the 'python' engine because the 'c' engine does not support sep=None with delim_whitespace=False; you can avoid this warning by specifying engine='python'.\n"
     ]
    }
   ],
   "source": [
    "#Create lists of dataframes for each condition\n",
    "path1 = os.getcwd()+'/WTUnind_Combined'\n",
    "path2 = os.getcwd()+'/WTInd_Combined'\n",
    "path3 = os.getcwd()+'/dNefUnind_Combined'\n",
    "path4 = os.getcwd()+'/dNefInd_Combined'\n",
    "\n",
    "wu = []\n",
    "wi = []\n",
    "du = []\n",
    "di = []\n",
    "\n",
    "for file in os.listdir(path1):\n",
    "    df = pd.read_csv(path1+'/'+file, sep=None)\n",
    "    df = df[['Vol (unit)', 'Surf (unit)']]\n",
    "    wu.append(df)\n",
    "\n",
    "for file in os.listdir(path2):\n",
    "    df = pd.read_csv(path2+'/'+file, sep=None)\n",
    "    df = df[['Vol (unit)', 'Surf (unit)']]\n",
    "    wi.append(df)\n",
    "    \n",
    "for file in os.listdir(path3):\n",
    "    df = pd.read_csv(path3+'/'+file, sep=None)\n",
    "    df = df[['Vol (unit)', 'Surf (unit)']]\n",
    "    du.append(df)\n",
    "    \n",
    "for file in os.listdir(path4):\n",
    "    df = pd.read_csv(path4+'/'+file, sep=None)\n",
    "    df = df[['Vol (unit)', 'Surf (unit)']]\n",
    "    di.append(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Creating concatenated dataframes for each condition to determine volume threshold\n",
    "wtun = pd.concat(wu)\n",
    "wtun_th = wtun['Vol (unit)'].quantile(0.75) + 3*(wtun['Vol (unit)'].quantile(0.75) - wtun['Vol (unit)'].quantile(0.25))\n",
    "wu_filt = wtun[wtun['Vol (unit)'] < wtun_th]\n",
    "\n",
    "wtind = pd.concat(wi)\n",
    "wtind_th = wtind['Vol (unit)'].quantile(0.75) + 3*(wtind['Vol (unit)'].quantile(0.75) - wtind['Vol (unit)'].quantile(0.25))\n",
    "wi_filt = wtind[wtind['Vol (unit)'] < wtind_th]\n",
    "\n",
    "dnun = pd.concat(du)\n",
    "dnun_th = dnun['Vol (unit)'].quantile(0.75) + 3*(dnun['Vol (unit)'].quantile(0.75) - dnun['Vol (unit)'].quantile(0.25))\n",
    "du_filt = dnun[dnun['Vol (unit)'] < dnun_th]\n",
    "                 \n",
    "dnind = pd.concat(di)\n",
    "dnind_th = dnind['Vol (unit)'].quantile(0.75) + 3*(dnind['Vol (unit)'].quantile(0.75) - dnind['Vol (unit)'].quantile(0.25))\n",
    "di_filt = dnind[dnind['Vol (unit)'] < dnind_th]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Getting counts of peroxisomes per cell for each condition following thresholding\n",
    "wu_count = []\n",
    "wi_count = []\n",
    "du_count = []\n",
    "di_count = []\n",
    "\n",
    "for df in wu:\n",
    "    temp = df[df['Vol (unit)'] < wtun_th]\n",
    "    wu_count.append(len(temp))\n",
    "    \n",
    "for df in wi:\n",
    "    temp = df[df['Vol (unit)'] < wtind_th]\n",
    "    wi_count.append(len(temp))\n",
    "    \n",
    "for df in du:\n",
    "    temp = df[df['Vol (unit)'] < dnun_th]\n",
    "    du_count.append(len(temp))\n",
    "    \n",
    "for df in di:\n",
    "    temp = df[df['Vol (unit)'] < dnind_th]\n",
    "    di_count.append(len(temp))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.20821046060713017\n",
      "0.0004914570137579358\n"
     ]
    }
   ],
   "source": [
    "#T-test for each pair of peroxisome counts\n",
    "stat1, pval1 = ttest_ind(wu_count, wi_count, equal_var=False)\n",
    "stat2, pval2 = ttest_ind(du_count, di_count, equal_var=False)\n",
    "\n",
    "print(pval1)\n",
    "print(pval2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Plotting all data for peroxisome counts\n",
    "templist = wu_count + wi_count + du_count + di_count\n",
    "df = pd.DataFrame(data=templist, columns=['Count'])\n",
    "df['Condition'] = ''\n",
    "df.loc[0:len(wu_count), 'Condition'] = 'Wild-type Uninduced'\n",
    "df.loc[len(wu_count):len(wu_count)+len(wi_count), 'Condition'] = 'Wild-type Induced'\n",
    "df.loc[len(wu_count)+len(wi_count):len(wu_count)+len(wi_count)+len(du_count), 'Condition'] = 'dNef Uninduced'\n",
    "df.loc[len(wu_count)+len(wi_count)+len(du_count):len(wu_count)+len(wi_count)+len(du_count)+len(di_count), 'Condition'] = 'dNef Induced'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Set working directory to folder comparing biological replicates\n",
    "os.chdir('C:/Users/ooma1/OneDrive - UC San Diego/Guatelli Lab/Cell Fractionation/FractPaperFigures')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ooma1\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:256: UserWarning: Matplotlib is currently using module://ipykernel.pylab.backend_inline, which is a non-GUI backend, so cannot show the figure.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 612x792 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Radar chart code from Matplotlib tutorial \n",
    "def radar_factory(num_vars, frame='circle'):\n",
    "    \"\"\"Create a radar chart with `num_vars` axes.\n",
    "\n",
    "    This function creates a RadarAxes projection and registers it.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    num_vars : int\n",
    "        Number of variables for radar chart.\n",
    "    frame : {'circle' | 'polygon'}\n",
    "        Shape of frame surrounding axes.\n",
    "\n",
    "    \"\"\"\n",
    "    # calculate evenly-spaced axis angles\n",
    "    theta = np.linspace(0, 2*np.pi, num_vars, endpoint=False)\n",
    "\n",
    "    def draw_poly_patch(self):\n",
    "        # rotate theta such that the first axis is at the top\n",
    "        verts = unit_poly_verts(theta + np.pi / 2)\n",
    "        return plt.Polygon(verts, closed=True, edgecolor='k')\n",
    "\n",
    "    def draw_circle_patch(self):\n",
    "        # unit circle centered on (0.5, 0.5)\n",
    "        return plt.Circle((0.5, 0.5), 0.5)\n",
    "\n",
    "    patch_dict = {'polygon': draw_poly_patch, 'circle': draw_circle_patch}\n",
    "    if frame not in patch_dict:\n",
    "        raise ValueError('unknown value for `frame`: %s' % frame)\n",
    "\n",
    "    class RadarAxes(PolarAxes):\n",
    "\n",
    "        name = 'radar'\n",
    "        # use 1 line segment to connect specified points\n",
    "        RESOLUTION = 1\n",
    "        # define draw_frame method\n",
    "        draw_patch = patch_dict[frame]\n",
    "\n",
    "        def __init__(self, *args, **kwargs):\n",
    "            super(RadarAxes, self).__init__(*args, **kwargs)\n",
    "            # rotate plot such that the first axis is at the top\n",
    "            self.set_theta_zero_location('N')\n",
    "\n",
    "        def fill(self, *args, **kwargs):\n",
    "            \"\"\"Override fill so that line is closed by default\"\"\"\n",
    "            closed = kwargs.pop('closed', True)\n",
    "            return super(RadarAxes, self).fill(closed=closed, *args, **kwargs)\n",
    "\n",
    "        def plot(self, *args, **kwargs):\n",
    "            \"\"\"Override plot so that line is closed by default\"\"\"\n",
    "            lines = super(RadarAxes, self).plot(*args, **kwargs)\n",
    "            for line in lines:\n",
    "                self._close_line(line)\n",
    "\n",
    "        def _close_line(self, line):\n",
    "            x, y = line.get_data()\n",
    "\n",
    "            if x[0] != x[-1]:\n",
    "                x = np.concatenate((x, [x[0]]))\n",
    "                y = np.concatenate((y, [y[0]]))\n",
    "                line.set_data(x, y)\n",
    "\n",
    "        def set_varlabels(self, labels):\n",
    "            self.set_thetagrids(np.degrees(theta), labels)\n",
    "\n",
    "        def _gen_axes_patch(self):\n",
    "            return self.draw_patch()\n",
    "\n",
    "        def _gen_axes_spines(self):\n",
    "            if frame == 'circle':\n",
    "                return PolarAxes._gen_axes_spines(self)\n",
    "            # The following is a hack to get the spines (i.e. the axes frame)\n",
    "            # to draw correctly for a polygon frame.\n",
    "\n",
    "            # spine_type must be 'left', 'right', 'top', 'bottom', or `circle`.\n",
    "            spine_type = 'circle'\n",
    "            verts = unit_poly_verts(theta + np.pi / 2)\n",
    "            # close off polygon by repeating first vertex\n",
    "            verts.append(verts[0])\n",
    "            path = Path(verts)\n",
    "\n",
    "            spine = Spine(self, spine_type, path)\n",
    "            spine.set_transform(self.transAxes)\n",
    "            return {'polar': spine}\n",
    "\n",
    "    register_projection(RadarAxes)\n",
    "    return theta\n",
    "\n",
    "\n",
    "def unit_poly_verts(theta):\n",
    "    \"\"\"Return vertices of polygon for subplot axes.\n",
    "\n",
    "    This polygon is circumscribed by a unit circle centered at (0.5, 0.5)\n",
    "    \"\"\"\n",
    "    x0, y0, r = [0.5] * 3\n",
    "    verts = [(r*np.cos(t) + x0, r*np.sin(t) + y0) for t in theta]\n",
    "    return verts\n",
    "\n",
    "\n",
    "def example_data():\n",
    "    data = [\n",
    "        ['ER', 'Endosome', 'Golgi', 'Large Protein\\nComplex', 'Lysosome', 'Mitochondrion', 'Plasma\\nmembrane'],\n",
    "        ('Wild-type', [wunind_mean, wind_mean]),\n",
    "        ('dNef', [dunind_mean, dind_mean])\n",
    "    ]\n",
    "    return data\n",
    "\n",
    "def realign_polar_xticks(ax):\n",
    "    for x, label in zip(ax.get_xticks(), ax.get_xticklabels()):\n",
    "        if np.sin(x) > 0.1:\n",
    "            label.set_horizontalalignment('right')\n",
    "        if np.sin(x) < -0.1:\n",
    "            label.set_horizontalalignment('left')\n",
    "\n",
    "N = 7\n",
    "theta = radar_factory(N, frame='polygon')\n",
    "\n",
    "data = example_data()\n",
    "spoke_labels = data.pop(0)\n",
    "spoke_labels_final = []\n",
    "\n",
    "fig = plt.figure(figsize=(8.5, 11))\n",
    "ax1 = fig.add_subplot(4, 2, 1, projection='radar')\n",
    "ax2 = fig.add_subplot(4, 2, 2, projection='radar')\n",
    "ax3 = fig.add_subplot(4, 2, 3)\n",
    "ax4 = fig.add_subplot(4, 2, 4)\n",
    "ax5 = fig.add_subplot(4, 2, 5)\n",
    "ax6 = fig.add_subplot(4, 2, 6)\n",
    "ax7 = fig.add_subplot(4, 2, 7)\n",
    "ax8 = fig.add_subplot(4, 2, 8)\n",
    "\n",
    "colors = ['purple', 'gold', 'purple', 'gold']\n",
    "\n",
    "for ax, (title, case_data) in zip([ax1, ax2], data):\n",
    "    ax.set_rgrids([0.2, 0.4, 0.6, 0.8])\n",
    "    ax.set_title(title, weight='bold', size='medium', position=(0.5, 1.15),\n",
    "                 horizontalalignment='center', verticalalignment='center')\n",
    "    for d, color in zip(case_data, colors):\n",
    "        ax.plot(theta, d, color=color, linewidth=1)\n",
    "        ax.fill(theta, d, facecolor=color, alpha=0.25)\n",
    "    ax.set_varlabels(spoke_labels)\n",
    "    realign_polar_xticks(ax)\n",
    "    ax.set_ylim(0, 0.6)\n",
    "# add legend relative to top-left plot\n",
    "labels = ('Uninduced', 'Induced')\n",
    "legend = ax1.legend(labels, loc=(1.15, 0.5),\n",
    "                   labelspacing=0.1, fontsize=10)\n",
    "ax1.annotate('A)', (-0.2, 1.15), xycoords='axes fraction', fontsize=12)\n",
    "\n",
    "# G.O. enrichment for label-based movement (Wild-type)\n",
    "wtgo_lb = [3.91e-6, 7.11e-6, 2.51e-5, 0.00015, 0.00015]\n",
    "wtgo_lb_log = -1*np.log10(wtgo_lb)\n",
    "wtgo_lb_terms = ['endomembrane\\nsystem (n=37)', 'membrane (n=52)', 'organelle\\nmembrane (n=30)', \n",
    "                 'endoplasmic reticulum\\nsubcompartment (n=15)', 'organelle\\nsubcompartment (n=19)']\n",
    "\n",
    "ax3.barh(range(5,0,-1), wtgo_lb_log, 0.5, tick_label = wtgo_lb_terms)\n",
    "ax3.set_xlabel('-log10(FDR)')\n",
    "ax3.set_title('Wild-type (70 hits)')\n",
    "ax3.set_xlim(0, 6)\n",
    "\n",
    "right_side = ax3.spines['right']\n",
    "right_side.set_visible(False)\n",
    "top_side = ax3.spines['top']\n",
    "top_side.set_visible(False)\n",
    "\n",
    "ax3.annotate('B)', (-0.2, 1.1), xycoords='axes fraction', fontsize=12)\n",
    "\n",
    "# G.O. enrichment for label-based movement (dNef)\n",
    "dnefgo_lb = [0.00055, 0.00055, 0.00055, 0.00055, 0.00055]\n",
    "dnefgo_lb_log = -1*np.log10(dnefgo_lb)\n",
    "dnefgo_lb_terms = ['cytoplasmic\\nvesicle (n=22)', 'SCAR complex\\n(n=3)', 'cell junction\\n(n=14)', 'lamellipodium\\n(n=7)', 'cytosol\\n(n=34)']\n",
    "\n",
    "ax4.barh(range(5,0,-1), dnefgo_lb_log, 0.5, tick_label = dnefgo_lb_terms)\n",
    "ax4.set_xlabel('-log10(FDR)')\n",
    "ax4.set_title('dNef (67 hits)')\n",
    "ax4.set_xlim(0, 6)\n",
    "\n",
    "right_side = ax4.spines['right']\n",
    "right_side.set_visible(False)\n",
    "top_side = ax4.spines['top']\n",
    "top_side.set_visible(False)\n",
    "\n",
    "# G.O. enrichment for centroid based movement (Wild-type)\n",
    "wtgo_cb = [2.98e-16, 6.98e-11, 5.16e-10, 5.16e-10, 6.98e-10]\n",
    "wtgo_cb_log = -1*np.log10(wtgo_cb)\n",
    "wtgo_cb_terms = ['peroxisome (n=21)', 'intracellular\\norganelle (n=162)', 'organelle\\nmembrane (n=72)', \n",
    "                 'membrane (n=128)', 'cytoplasm (n=152)']\n",
    "\n",
    "ax5.barh(range(5,0,-1), wtgo_cb_log, 0.5, tick_label = wtgo_cb_terms)\n",
    "ax5.set_xlabel('-log10(FDR)')\n",
    "ax5.set_title('Wild-type (188 hits)')\n",
    "ax5.set_xlim(0, 18)\n",
    "\n",
    "right_side = ax5.spines['right']\n",
    "right_side.set_visible(False)\n",
    "top_side = ax5.spines['top']\n",
    "top_side.set_visible(False)\n",
    "\n",
    "ax5.annotate('C)', (-0.2, 1.1), xycoords='axes fraction', fontsize=12)\n",
    "\n",
    "# G.O. enrichment for centroid based movement (dNef)\n",
    "dnefgo_cb = [2.1e-10, 2.1e-10, 5.39e-10, 9.51e-9, 3.06e-8]\n",
    "dnefgo_cb_log = -1*np.log10(dnefgo_cb)\n",
    "dnefgo_cb_terms = ['nuclear lumen (n=80)', 'nucleoplasm (n=73)', 'protein-containing\\ncomplex (n=87)', \n",
    "                   'intracellular\\norganelle lumen (n=88)', 'intracellular (n=164)']\n",
    "\n",
    "ax6.barh(range(5,0,-1), dnefgo_cb_log, 0.5, tick_label = dnefgo_cb_terms)\n",
    "ax6.set_xlabel('-log10(FDR)')\n",
    "ax6.set_title('dNef (179 hits)')\n",
    "ax6.set_xlim(0, 18)\n",
    "\n",
    "right_side = ax6.spines['right']\n",
    "right_side.set_visible(False)\n",
    "top_side = ax6.spines['top']\n",
    "top_side.set_visible(False)\n",
    "\n",
    "# IF images of eGFP-SKL Jurkat cells\n",
    "gfpskl = mpimg.imread('Fig6_eGFP_SKL_IF.png')\n",
    "ax7.imshow(gfpskl)\n",
    "ax7.axis('off')\n",
    "\n",
    "ax7.annotate('D)', (-0.25, 1.1), xycoords='axes fraction', fontsize=12)\n",
    "ax7.annotate('Wild-type', (-0.05, 0.75), xycoords='axes fraction', fontsize=10, horizontalalignment='right')\n",
    "ax7.annotate('dNef', (-0.05, 0.225), xycoords='axes fraction', fontsize=10, horizontalalignment='right')\n",
    "ax7.annotate('Uninduced', (0.25, 1.05), xycoords='axes fraction', fontsize=10, horizontalalignment='center')\n",
    "ax7.annotate('Induced', (0.75, 1.05), xycoords='axes fraction', fontsize=10, horizontalalignment='center')\n",
    "ax7.annotate('Peroxisomes', (0.5, -0.065), xycoords='axes fraction', fontsize=10, horizontalalignment='center', color='lime')\n",
    "ax7.annotate('Plasma membrane', (0.5, -0.13), xycoords='axes fraction', fontsize=10, horizontalalignment='center', color='red')\n",
    "ax7.annotate('Nucleus', (0.5, -0.195), xycoords='axes fraction', fontsize=10, horizontalalignment='center', color='blue')\n",
    "\n",
    "# Peroxisome quants\n",
    "sns.catplot(x='Condition', y='Count', data=df, kind='swarm', ax=ax8, s=2)\n",
    "\n",
    "ax8.plot([-0.4, 0.4], [mean(wu_count), mean(wu_count)], color='k', linewidth=0.75)\n",
    "ax8.plot([0.6, 1.4], [mean(wi_count), mean(wi_count)], color='k', linewidth=0.75)\n",
    "ax8.plot([1.55, 2.45], [mean(du_count), mean(du_count)], color='k', linewidth=0.75)\n",
    "ax8.plot([2.6, 3.4], [mean(di_count), mean(di_count)], color='k', linewidth=0.75)\n",
    "\n",
    "ax8.set_xticklabels(['Wild-type\\nUninduced', 'Wild-type\\nInduced', 'dNef\\nUninduced', 'dNef\\nInduced'], fontsize=7)\n",
    "ax8.set_xlabel('')\n",
    "ax8.set_ylabel('Peroxisomes per cell')\n",
    "ax8.set_ylim([-5, 200])\n",
    "\n",
    "ax8.plot([0, 1], [175, 175], linewidth=0.5, color='k')\n",
    "ax8.text(0.5, 176, 'p = {:0.4f}'.format(pval1), ha='center', va='bottom', color='k', fontsize=6)\n",
    "\n",
    "ax8.plot([2, 3], [175, 175], linewidth=0.5, color='k')\n",
    "ax8.text(2.5, 176, 'p = {:0.4f}'.format(pval2), ha='center', va='bottom', color='k', fontsize=6)\n",
    "\n",
    "ax8.annotate('E)', (-0.3, 1.1), xycoords='axes fraction', fontsize=12)\n",
    "\n",
    "fig.suptitle('Figure 6', x=0, y=1, fontsize=12)\n",
    "\n",
    "fig.tight_layout()\n",
    "fig.savefig('Figure6.pdf', dpi=500, bbox_inches='tight')\n",
    "fig.show()"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}