mito_ma.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4296be8f-d457-440a-b402-10f8ec82eca7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from os.path import getsize\n",
    "from io import StringIO\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from scipy.cluster import hierarchy\n",
    "from scipy import stats\n",
    "from scipy.spatial.distance import euclidean\n",
    "import statsmodels.api as sm\n",
    "import statsmodels.formula.api as smf\n",
    "from statsmodels.stats.multitest import multipletests\n",
    "import intervaltree\n",
    "import itertools\n",
    "import random\n",
    "import re\n",
    "from Bio import SeqIO\n",
    "from Bio import AlignIO\n",
    "from Bio import Seq\n",
    "from Bio import SeqRecord\n",
    "import pysam\n",
    "import gzip\n",
    "from matplotlib import pyplot as plt\n",
    "from matplotlib.colors import ListedColormap\n",
    "from matplotlib.patches import FancyArrow\n",
    "from matplotlib.patches import Arc\n",
    "from matplotlib.patches import Rectangle\n",
    "from matplotlib.patches import FancyBboxPatch\n",
    "from matplotlib.patches import BoxStyle as bs\n",
    "from matplotlib.patches import Polygon\n",
    "from matplotlib.lines import Line2D\n",
    "from matplotlib.colors import LinearSegmentedColormap\n",
    "from matplotlib.offsetbox import OffsetImage, AnnotationBbox\n",
    "from matplotlib.ticker import MultipleLocator\n",
    "import seaborn as sns\n",
    "from progressbar import ProgressBar\n",
    "import pickle as pkl\n",
    "from copy import copy\n",
    "import colorcet\n",
    "import PIL\n",
    "rc_sns = {'ytick_color':'k', 'xtick_color':'k', 'text_color':'k', 'font.sans-serif':'DejaVu Sans', 'figure.facecolor':(1,1,1,1)}\n",
    "sns.set_style(style='ticks', rc=rc_sns)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48c33a63-772f-416e-b9b2-82e72f3236f0",
   "metadata": {},
   "source": [
    "# Import and process metadata tables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "29ec9ce7-4fb0-4237-a53d-b1e610316d9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# parse info table for MA lines\n",
    "ma_strains = pd.read_csv('/mnt/HDD3/mito_ma/script/ma_strains.tsv', sep='\\t', index_col=0)\n",
    "\n",
    "#path on katak\n",
    "path_ref = '/home/mahen44/mito_ma/ref/'\n",
    "path_reads = {'HI':'/home/mahen44/MutationAccum/Helene/1_Trimm/Trimmo_1b/',\n",
    "              'NS':'/home/mahen44/MA_lines_2019/1.Trimmo/Trimmo/'}\n",
    "\n",
    "for cross, df in ma_strains.groupby('cross'):\n",
    "    if cross in ['H1','H2']:\n",
    "        ma_strains.loc[df.index, 'ref_map'] = f'{path_ref}ref_genome_BSc.mt_artSc.fasta'\n",
    "    elif cross == 'P':\n",
    "        for s, df1 in df.groupby('strain'):\n",
    "            #if parent in BSc crosses, must map on both references, so that BAM headers are complete\n",
    "            #for downstream variant calling\n",
    "            if s in ['LL2013_040','LL2013_054']:\n",
    "                ma_strains.loc[df1.index, 'ref_map'] = f'{path_ref}ref_genome_BSc.mt_artSc.fasta'\n",
    "            else:\n",
    "                ma_strains.loc[df1.index, 'ref_map'] = f'{path_ref}ref_genome_BSc.mt_art.fasta'\n",
    "    else:\n",
    "        ma_strains.loc[df.index, 'ref_map'] = f'{path_ref}ref_genome_BSc.mt_art.fasta'\n",
    "        \n",
    "for ins, df in ma_strains.groupby('instrument'):\n",
    "    ma_strains.loc[df.index , 'R1'] = df['filename'].apply(lambda x: f'{path_reads[ins]}{x}_outR1P.fastq.gz')\n",
    "    ma_strains.loc[df.index , 'R2'] = df['filename'].apply(lambda x: f'{path_reads[ins]}{x}_outR2P.fastq.gz')\n",
    "    \n",
    "# re-export ma_strains\n",
    "#ma_strains.to_csv('/mnt/HDD3/mito_ma/script/ma_strains_map.tsv', sep='\\t')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1913bf56-d32f-4fa7-97f3-20e7d2854918",
   "metadata": {},
   "outputs": [],
   "source": [
    "# parse metadata table for MA lines and edit\n",
    "ma_strains = pd.read_csv('/mnt/HDD3/mito_ma/script/ma_strains_mthap.tsv', sep='\\t', index_col=0)\n",
    "\n",
    "cross_alias = {'VL3':'CC1',\n",
    "              'VL4':'CC2',\n",
    "              'VL5':'CC3',\n",
    "              'VL1':'BB1',\n",
    "              'VL2':'BB2',\n",
    "              'L1':'BC1',\n",
    "              'L2':'BC2',\n",
    "              'M1':'BA1',\n",
    "              'M2':'BA2',\n",
    "              'H1':'BSc1',\n",
    "              'H2':'BSc2'}\n",
    "cross_order = {j:i for i,j in enumerate(['CC1', 'CC2', 'CC3', 'BB1', 'BB2', 'BC1', 'BC2', 'BA1', 'BA2', 'BSc1', 'BSc2'])}\n",
    "\n",
    "ma_strains['cross'] = ma_strains['cross'].replace(cross_alias)\n",
    "ma_strains['strain_passage'] = ma_strains.apply(lambda x: f'{x[\"strain\"]}_P{x[\"passage\"]:.0f}', axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a6f8b76-b790-4059-b874-d8046cc5a0d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# define general dictionaries\n",
    "parents_dict = {'CC1':('HI.4803.003.N712---N505.LL2011_004', 'NS.1250.002.N712---N505.MSH-587-1'),\n",
    "               'CC2':('HI.4803.003.N711---N508.LL2011_009', 'NS.1250.002.N712---N507.LL2011_012'),\n",
    "               'CC3':('HI.4803.003.N711---N508.LL2011_009', 'NS.1250.002.N712---N506.LL2011_001'),\n",
    "               'BB1':('HI.4803.003.N712---N504.MSH-604', 'HI.4803.003.N712---N508.LL2012_028'),\n",
    "               'BB2':('HI.4803.003.N711---N507.UWOPS-91-202', 'HI.4803.003.N712---N503.LL2012_021'),\n",
    "               'BC1':('HI.4803.003.N712---N504.MSH-604', 'HI.4803.003.N712---N505.LL2011_004'),\n",
    "               'BC2':('HI.4803.003.N711---N507.UWOPS-91-202', 'HI.4803.003.N711---N508.LL2011_009'),\n",
    "               'BA1':('HI.4803.003.N712---N504.MSH-604', 'HI.4803.003.N712---N506.YPS644'),\n",
    "               'BA2':('HI.4803.003.N711---N507.UWOPS-91-202', 'HI.4803.003.N712---N517.YPS744'),\n",
    "               'BSc1':('HI.4803.003.N712---N504.MSH-604', 'HI.4803.003.N712---N507.LL2013_040'),\n",
    "               'BSc2':('HI.4803.003.N711---N507.UWOPS-91-202', 'HI.4803.003.N712---N502.LL2013_054')}\n",
    "\n",
    "parents_filename = {'MSH-604':'HI.4803.003.N712---N504.MSH-604',\n",
    "                   'UWOPS-91-202':'HI.4803.003.N711---N507.UWOPS-91-202',\n",
    "                   'LL2012_021':'HI.4803.003.N712---N503.LL2012_021',\n",
    "                   'LL2012_028':'HI.4803.003.N712---N508.LL2012_028',\n",
    "                   'LL2011_004':'HI.4803.003.N712---N505.LL2011_004',\n",
    "                   'LL2011_009':'HI.4803.003.N711---N508.LL2011_009',\n",
    "                   'MSH-587-1':'NS.1250.002.N712---N505.MSH-587-1',\n",
    "                   'LL2011_012':'NS.1250.002.N712---N507.LL2011_012',\n",
    "                   'LL2011_001':'NS.1250.002.N712---N506.LL2011_001',\n",
    "                   'YPS644':'HI.4803.003.N712---N506.YPS644',\n",
    "                   'YPS744':'HI.4803.003.N712---N517.YPS744',\n",
    "                   'LL2013_040':'HI.4803.003.N712---N507.LL2013_040',\n",
    "                   'LL2013_054':'HI.4803.003.N712---N502.LL2013_054'}\n",
    "\n",
    "parents_group = {'MSH-604':'SpB',\n",
    "                   'UWOPS-91-202':'SpB',\n",
    "                   'LL2012_021':'SpB',\n",
    "                   'LL2012_028':'SpB',\n",
    "                   'LL2011_004':'SpC',\n",
    "                   'LL2011_009':'SpC',\n",
    "                   'MSH-587-1':'SpC',\n",
    "                   'LL2011_012':'SpC',\n",
    "                   'LL2011_001':'SpC',\n",
    "                   'YPS644':'SpA',\n",
    "                   'YPS744':'SpA',\n",
    "                   'LL2013_040':'Sc',\n",
    "                   'LL2013_054':'Sc'}\n",
    "\n",
    "parents_color = {'MSH-604':'red',\n",
    "                   'UWOPS-91-202':'red',\n",
    "                   'LL2012_021':'darkred',\n",
    "                   'LL2012_028':'darkred',\n",
    "                   'LL2011_004':'dodgerblue',\n",
    "                   'LL2011_009':'dodgerblue',\n",
    "                   'MSH-587-1':'midnightblue',\n",
    "                   'LL2011_012':'midnightblue',\n",
    "                   'LL2011_001':'midnightblue',\n",
    "                   'YPS644':'limegreen',\n",
    "                   'YPS744':'limegreen',\n",
    "                   'LL2013_040':'dimgrey',\n",
    "                   'LL2013_054':'dimgrey'}\n",
    "\n",
    "cross_color = ma_strains.groupby('cross')['cross_color'].apply(lambda x: x.iloc[0]).to_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58b328a3-78a0-4020-8399-a4acc5700eab",
   "metadata": {},
   "outputs": [],
   "source": [
    "# parse list of features that show presence/absence polymorphisms\n",
    "with open('/mnt/HDD3/mito_nanopore/artificial_genome/pres_abs_poly.txt', 'r') as handle:\n",
    "    pres_abs_poly = handle.read().splitlines()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8af559d-345d-4856-9ef7-f1570cb05fb0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# export lists of bam files for freebayes\n",
    "for cross, df in ma_strains.sort_values(by=['strain','passage']).groupby('cross'):\n",
    "    if cross in cross_order:\n",
    "        filenames = list(parents_dict[cross]) + list(df['filename'].values)\n",
    "        #with open(f'/mnt/HDD3/mito_ma/freebayes/bam_files_{cross}.txt', 'w') as handle:\n",
    "        #    handle.write('\\n'.join([f'/mnt/HDD3/mito_ma/bam/{i}.mt.rmdup.rg.bam' for i in filenames]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c220ad29-1e00-4c26-a532-124964039585",
   "metadata": {},
   "source": [
    "# Define general functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de031c30-eb7b-401e-894c-6b04e309afe9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_pval_symbol(p):\n",
    "    if p<=0.001:\n",
    "        pdisplay = '***'\n",
    "    elif p<=0.01:\n",
    "        pdisplay = '**'\n",
    "    elif p<=0.05:\n",
    "        pdisplay = '*'\n",
    "    else:\n",
    "        pdisplay = None\n",
    "    return pdisplay\n",
    "\n",
    "def plot_pval_text(p):\n",
    "    if p<=0.001:\n",
    "        pdisplay = f'{p:.1e}'\n",
    "    elif p<=0.01:\n",
    "        pdisplay = f'{p:.4f}'\n",
    "    elif p<=0.1:\n",
    "        pdisplay = f'{p:.3f}'\n",
    "    elif p<=1:\n",
    "        pdisplay = f'{p:.2f}'\n",
    "    elif p>1:\n",
    "        pdisplay = f'{p:.1f}'\n",
    "    else:\n",
    "        pdisplay = None\n",
    "    return pdisplay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f442fefc-c098-4e66-b1fd-08299cab5074",
   "metadata": {},
   "outputs": [],
   "source": [
    "def nan_distance(u,v):\n",
    "    U = u[(~np.isnan(u)) & (~np.isnan(v))]\n",
    "    V = v[(~np.isnan(u)) & (~np.isnan(v))]\n",
    "    return (U != V).sum()/U.shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32832d79-a27d-4be9-a369-f79a4bd8ef32",
   "metadata": {},
   "source": [
    "# Import genome assemblies and annotations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6af4bd7b-ce41-495f-aca0-c2e408fe09cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "GFF = pd.read_csv('/mnt/HDD3/mito_nanopore/mfannot/gff_edit.csv', sep='\\t')\n",
    "GFF.columns = list(range(9)) + list(GFF.columns)[9:]\n",
    "GFF = GFF.astype({3:int,4:int,'strain_order':int,'annot_width':float,'annot_plot_order':int})\n",
    "\n",
    "artificial_genome_feat = pd.read_csv('/mnt/HDD3/mito_nanopore/artificial_genome/artificial_genome.features.csv', sep=',')\n",
    "artificial_genome_feat.columns = list(range(9)) + list(artificial_genome_feat.columns)[9:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "47eb98a2-e4ae-46fd-b295-5307f68205bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('/mnt/HDD3/mito_nanopore/artificial_genome/artificial_genome.fasta') as handle:\n",
    "    artificial_genome = SeqIO.read(handle, 'fasta')\n",
    "ref_genome_length = len(artificial_genome.seq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "508b7cdf-4ac9-404a-8050-6a1a264cde81",
   "metadata": {},
   "outputs": [],
   "source": [
    "parents_order = GFF.groupby('strain').apply(lambda x: x.iloc[0]['strain_order']).sort_values()\n",
    "\n",
    "at_dict = GFF.groupby('Name').apply(lambda x: x.iloc[0]['annot_type']).to_dict()\n",
    "at_dict.update(artificial_genome_feat.groupby('Name').apply(lambda x: x.iloc[0]['annot_type']).to_dict())\n",
    "\n",
    "genes_to_display = ['atp6',\n",
    "                    'cob',\n",
    "                    'atp9',\n",
    "                    'rps3',\n",
    "                    'rnl',\n",
    "                    'cox2',\n",
    "                    'cox3',\n",
    "                    'rnpB',\n",
    "                    'rns',\n",
    "                    'cox1',\n",
    "                    'atp8',\n",
    "                    'trna']\n",
    "\n",
    "genes_alias = dict(zip(genes_to_display, ['$ATP6$',\n",
    "                                          '$COB$',\n",
    "                                          '$OLI1$',\n",
    "                                          '$VAR1$',\n",
    "                                          '21S rRNA',\n",
    "                                          '$COX2$',\n",
    "                                          '$COX3$',\n",
    "                                          '$RPM1$',\n",
    "                                          '15S rRNA',\n",
    "                                          '$COX1$',\n",
    "                                          '$ATP8$',\n",
    "                                          'tRNAs']))\n",
    "cond_alias = {'YPD_25':'YPD 25°C', 'YPD_37':'YPD 37°C', 'YPEG_25':'YPEG 25°C', 'YPEG_37':'YPEG 37°C'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f84990e-3153-48b8-b260-9b9b6a34d8d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# define aliases for plotting feature names\n",
    "pres_abs_poly_alias = {}\n",
    "intron_gene_alias = {'a':'$cox1$', 'b':'$cob$'}\n",
    "intron_i_alias = {'alpha':r'$\\alpha$', 'beta':r'$\\beta$', 'gamma':r'$\\gamma$'}\n",
    "for a in pres_abs_poly:\n",
    "    #genes\n",
    "    if a in genes_alias:\n",
    "        pres_abs_poly_alias[a] = genes_alias[a]\n",
    "    \n",
    "    #trna\n",
    "    elif a[:3] == 'trn':\n",
    "        m = re.match('(?:trn)([ACDEFGHIKLMNPQRSTVWY*]{1})\\(([aucg]{3,4})\\)', a)\n",
    "        AA, cd =  m.groups()\n",
    "        pres_abs_poly_alias[a] = f't{AA}({cd.upper()})Q'\n",
    "    \n",
    "    #orf\n",
    "    elif '_orf' in a:\n",
    "        a1 = a.split('_')[0]\n",
    "        if a1 in genes_alias:\n",
    "            pres_abs_poly_alias[a] = f'{genes_alias[a1]} ORF'\n",
    "        else:\n",
    "            m = re.match('([ab])i([1-5])(alpha|beta|gamma){0,1}', a1)\n",
    "            g,n,i = m.groups()\n",
    "            if i:\n",
    "                i = intron_i_alias[i]\n",
    "            else:\n",
    "                i = ''\n",
    "            pres_abs_poly_alias[a] = fr'{intron_gene_alias[g]}-I{n}{i} ORF'\n",
    "            \n",
    "    elif a == 'omega':\n",
    "        pres_abs_poly_alias[a] = '$\\omega$'\n",
    "        \n",
    "    elif a == 'ORF1':\n",
    "        pres_abs_poly_alias[a] = 'ORF1'\n",
    "    \n",
    "    else:\n",
    "        m = re.match('([ab])i([1-5])(alpha|beta|gamma){0,1}', a)\n",
    "        g,n,i = m.groups()\n",
    "        if i:\n",
    "            i = intron_i_alias[i]\n",
    "        else:\n",
    "            i = ''\n",
    "        pres_abs_poly_alias[a] = f'{intron_gene_alias[g]}-I{n}{i}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b04312bd-8065-42d2-b47e-72da7d17615f",
   "metadata": {},
   "outputs": [],
   "source": [
    "#add 500-bp wide windows to artificial genome gff for unannotated regions\n",
    "other_idx = artificial_genome_feat.shape[0]\n",
    "i = 1\n",
    "annot_other = []\n",
    "while i+500 < ref_genome_length:\n",
    "    new = pd.Series(['mt_art', 'manual', 'intergenic', i, i+499, f'other{other_idx}', '0.8', 'other', 0],\n",
    "                   index=[0, 1, 2, 3, 4, 'Name', 'annot_color', 'annot_type', 'annot_plot_order'], name=other_idx)\n",
    "    annot_other.append(new)\n",
    "    i += 500\n",
    "    other_idx += 1\n",
    "#add final line\n",
    "new = pd.Series(['mt_art', 'manual', 'intergenic', i, ref_genome_length, f'other{other_idx}', '0.8', 'other', 0],\n",
    "               index=[0, 1, 2, 3, 4, 'Name', 'annot_color', 'annot_type', 'annot_plot_order'], name=other_idx)\n",
    "annot_other.append(new)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f77014c8-b75e-44ef-8b1c-b504dc62606f",
   "metadata": {},
   "outputs": [],
   "source": [
    "artificial_genome_feat = pd.concat([artificial_genome_feat, pd.DataFrame(annot_other)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53c7e11e-debc-4db2-b05b-861bed1ede5e",
   "metadata": {},
   "outputs": [],
   "source": [
    "annot_type_order = {'exon':0, 'intron':1, 'orf':2, 'rna_exon':3, 'tRNA':4, 'gc_cluster':5, 'other':6}\n",
    "annot_type_color = artificial_genome_feat.groupby('annot_type').apply(lambda x: x.iloc[0]['annot_color']).loc[annot_type_order].to_dict()\n",
    "annot_type_color['other'] = '0.8'\n",
    "annot_type_alias = dict(zip(['exon','intron','orf','rna_exon','tRNA','gc_cluster','other'],\n",
    "                           ['Exon','Intron','ORF','RNA exon','tRNA','GC cluster','Unannotated']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d11ce0e-09a3-4705-ab1f-d63f4ed609df",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import assemblies\n",
    "CORR = {}\n",
    "\n",
    "for s in ma_strains.loc[ma_strains['cross']=='P', 'strain']:\n",
    "    with open(f'/mnt/HDD3/mito_nanopore/polishing/{s}/{s}.nanopolish.pilon.fasta') as handle:\n",
    "        CORR[s] = SeqIO.read(handle, 'fasta')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2485a0bb-f065-496d-ba34-27974d78daff",
   "metadata": {},
   "outputs": [],
   "source": [
    "#export gff annotations for 13 genomes\n",
    "\n",
    "for s, gff in GFF.groupby('strain'):\n",
    "\n",
    "    new_col8 = []\n",
    "    for i in gff['Name'].values:\n",
    "        if i in pres_abs_poly_alias:\n",
    "            new = pres_abs_poly_alias[i].replace('\\\\','').replace('$','')\n",
    "        else:\n",
    "            new = i\n",
    "        new_col8.append(f'ID={new};Name={new};transl_table=3;gene={new}')\n",
    "    gff[8] = new_col8\n",
    "    gff[2] = gff['annot_type']\n",
    "    gff[0] = f'{s}.mt_genome'\n",
    "    gff = gff[range(9)].astype(str).values\n",
    "    \n",
    "    if 'LL2013' in s:\n",
    "        species = 'Saccharomyces cerevisiae'\n",
    "    else:\n",
    "        species = 'Saccharomyces paradoxus'\n",
    "          \n",
    "    #parse genome length and add to the file header\n",
    "    \n",
    "    seq_id = f'{s}.mt_genome [organism={species}] complete mitochondrial genome of strain {s}'\n",
    "    seq = SeqRecord.SeqRecord(seq=CORR[s].seq, id=seq_id, description='')\n",
    "    \n",
    "    #with open(f'/mnt/HDD3/mito_nanopore/final_assemblies/{s}.mt_genome.fasta', 'w') as handle:\n",
    "    #    SeqIO.write(seq, handle, 'fasta')\n",
    "    \n",
    "    header = f'##gff-version 3\\n##sequence-region 1 {len(seq.seq)}\\n'\n",
    "    content = '\\n'.join(['\\t'.join(line) for line in gff])\n",
    "    \n",
    "    #write\n",
    "    #with open(f'/mnt/HDD3/mito_nanopore/final_assemblies/{s}.mt_genome.gff', 'w') as handle:\n",
    "    #    handle.write(header+content)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b27c4e5-49e9-4725-921d-116b11860118",
   "metadata": {},
   "source": [
    "# Import vcf files for mtDNAs "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9cb77b8e-1a55-4732-bc3e-d1840891f2b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import vcf files\n",
    "def parse_vcf(vcf_file, split_multi=True):\n",
    "\n",
    "    skiprows = 0\n",
    "    with gzip.open(vcf_file, 'rb') as handle:\n",
    "        line = handle.readline()\n",
    "        while line.decode('utf-8')[:2] == '##':\n",
    "            skiprows += 1\n",
    "            line = handle.readline()\n",
    "\n",
    "    vcf = pd.read_csv(vcf_file, sep='\\t', compression='gzip', skiprows=skiprows)\n",
    "    samples = vcf.columns[9:]\n",
    "\n",
    "    # attribute unique IDs to variants\n",
    "    vcf['var_uid'] = [f'v{i}' for i in range(vcf.shape[0])]\n",
    "    vma_idx = 0\n",
    "    for vma, df in vcf.groupby(['#CHROM','POS','REF']):\n",
    "        vcf.loc[df.index, 'vma_uid'] = f'vma{vma_idx}'\n",
    "        vma_idx += 1\n",
    "\n",
    "    vcf.index = vcf['var_uid'].values\n",
    "    # melt vcf\n",
    "    vcf_melt = pd.melt(vcf, id_vars=['var_uid','vma_uid'], value_vars=samples, var_name='filename', value_name='GT')\n",
    "\n",
    "    Formats = set(vcf['FORMAT'])\n",
    "    if len(Formats) == 1:\n",
    "        Format = list(Formats)[0].split(':')\n",
    "        for i,tag in enumerate(Format):\n",
    "            new = vcf_melt['GT'].apply(lambda x: x.split(':')[i]).replace('.', np.nan)\n",
    "            if tag in ['GT','DP','RO','AO','QR','QA']:\n",
    "                new = new.astype(float)\n",
    "            vcf_melt[tag.lower()] = new\n",
    "\n",
    "    # get counts of supporting observations, and drop genotypes called with <=1 obs\n",
    "    for a, df in vcf_melt.groupby('gt'):\n",
    "        if a == 0:\n",
    "            vcf_melt.loc[df.index, 'obs'] = df['ro']\n",
    "            vcf_melt.loc[df.index, 'ratio'] = df['ro']/df['dp']\n",
    "        elif a == 1:\n",
    "            vcf_melt.loc[df.index, 'obs'] = df['ao']\n",
    "            vcf_melt.loc[df.index, 'ratio'] = df['ao']/df['dp']\n",
    "    vcf_melt.loc[vcf_melt['obs']<=1, 'gt'] = np.nan\n",
    "\n",
    "    vcf_melt['a_ratio'] = vcf_melt['ao']/vcf_melt['dp']\n",
    "    vcf_melt['r_ratio'] = vcf_melt['ro']/vcf_melt['dp']\n",
    "    vcf_melt['#CHROM'] = vcf.loc[vcf_melt['var_uid'], '#CHROM'].values\n",
    "    vcf_melt['POS'] = vcf.loc[vcf_melt['var_uid'], 'POS'].values\n",
    "    vcf_melt['REF'] = vcf.loc[vcf_melt['var_uid'], 'REF'].values\n",
    "    vcf_melt['ALT'] = vcf.loc[vcf_melt['var_uid'], 'ALT'].values\n",
    "\n",
    "    vcf = vcf.drop(samples, axis=1)\n",
    "\n",
    "    return vcf, vcf_melt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc6f658b-8d8b-41f8-b22a-cfba1a61d580",
   "metadata": {},
   "outputs": [],
   "source": [
    "VCF = {}\n",
    "VCF_MELT = {}\n",
    "\n",
    "for cross in cross_order:\n",
    "\n",
    "    vcf, vcf_melt = parse_vcf(f'/mnt/HDD3/mito_ma/freebayes/freebayes.{cross}.breakmulti.vcf.gz')\n",
    "    VCF[cross] = vcf\n",
    "    VCF_MELT[cross] = vcf_melt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1933f7a8-48df-483e-b636-4859f3e3ab59",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Liftover procedure from whole genome alignments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4833bd05-b2e9-4892-adef-1922480a88b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# parse maf alignments\n",
    "\n",
    "def parse_maf(s, path):\n",
    "\n",
    "    #s_mugsy = f'{s.replace(\"-\",\"_\")}.mt_pilon'\n",
    "    aln = list(AlignIO.parse(path, 'maf'))\n",
    "    \n",
    "    maf = {ai:{seq.id:seq for seq in a} for (ai,a) in enumerate(aln) if len(a)==2}\n",
    "    # flip any alignment block for which the ref sequence is reversed\n",
    "    for ai, a in maf.items():\n",
    "        seq_names = a.keys()\n",
    "        ref_name = 'artificial_genome.mt_art'\n",
    "        qry_name = [i for i in seq_names if i!=ref_name][0]\n",
    "        ref = a[ref_name]\n",
    "        qry = a[qry_name]\n",
    "        ref_strand = ref.annotations['strand']\n",
    "        qry_strand = qry.annotations['strand']\n",
    "        \n",
    "        if ref_strand == -1:\n",
    "            ref.annotations['start'] = ref.annotations['srcSize'] - (ref.annotations['start'] + ref.annotations['size'])\n",
    "            for seq in (ref, qry):\n",
    "                seq.seq = seq.seq.reverse_complement()\n",
    "            \n",
    "                seq.annotations['strand'] = seq.annotations['strand']*(-2) # mark the flipped sequences as 2\n",
    "                maf[ai][seq.id] = seq\n",
    "            \n",
    "        if qry_strand == -1:\n",
    "            qry.annotations['start'] = qry.annotations['srcSize'] - (qry.annotations['start'] + qry.annotations['size'])\n",
    "    \n",
    "    return maf\n",
    "\n",
    "def liftover_maf(maf):\n",
    "    \n",
    "    lift_list = []\n",
    "\n",
    "    for ai, a in maf.items():\n",
    "\n",
    "        ref = a['artificial_genome.mt_art']\n",
    "        al = len(ref.seq)\n",
    "        ref_len = ref.annotations['size']\n",
    "        ref_start = ref.annotations['start']\n",
    "        ref_offset = 0\n",
    "        while ref.seq[ref_offset] == '-':\n",
    "            ref_offset += 1\n",
    "\n",
    "        lift = range(al)\n",
    "        ref_pos = []\n",
    "        for i in lift:\n",
    "            # build ref positions\n",
    "            if ref.seq[i] == '-':\n",
    "                ref_pos.append(-1)\n",
    "            else:\n",
    "                ref_pos.append(ref_start)\n",
    "                ref_start += 1\n",
    "\n",
    "        ref_pos = np.array(ref_pos)\n",
    "\n",
    "        lift_list.append(pd.DataFrame([ref_pos,lift,np.repeat(ai, al)],\n",
    "                                      index=['ref_pos','lift','aln']).T.astype(np.int32))\n",
    "\n",
    "    lift_list = pd.concat(lift_list).reset_index(drop=True)\n",
    "    lift_list.index = lift_list['ref_pos'].values\n",
    "    \n",
    "    return lift_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86fe4f71-1a8d-47c8-8194-7509bfe274d3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "MAF = {}\n",
    "for s in ma_strains.loc[ma_strains['cross']=='P', 'strain']:\n",
    "    MAF[s] = parse_maf(s, f'/mnt/HDD3/mito_nanopore/mugsy/{s}/mt_art.maf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0364906-0ccd-498d-8bc4-5bb7fe44d61d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "LIFT = {}\n",
    "for s in ma_strains.loc[ma_strains['cross']=='P', 'strain']:\n",
    "    LIFT[s] = liftover_maf(MAF[s])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60ec5c26-b738-4687-9a83-0a2df5aecc99",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# check the lift procedure\n",
    "for s, lift in LIFT.items():\n",
    "    for a, df in lift.groupby('aln'):\n",
    "        df1 = df.loc[df['ref_pos']!=-1]\n",
    "        test1 = np.array([artificial_genome.seq[i] for i in df1['ref_pos']])\n",
    "        test2 = np.array([MAF[s][a]['artificial_genome.mt_art'][i] for i in df1['lift']])\n",
    "        if np.all(test1 == test2):\n",
    "            print(f'pass {s} {a}')\n",
    "        else:\n",
    "            print(f'error {s} {a}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "986586d4-f7b6-4ddf-892f-587c853bf140",
   "metadata": {},
   "source": [
    "## Compute identity levels among parental strains per annotation type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bed6cca1-1c95-4e18-95e8-7bf93496b53b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#define interval tree to query positions for genomic features\n",
    "gft = intervaltree.IntervalTree()\n",
    "for i in artificial_genome_feat.index:\n",
    "    start, end = artificial_genome_feat.loc[i, [3,4]].values\n",
    "    gft[start:end+1] = i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64604297-befb-42b4-a31f-f87cbfe251d1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# categorize genome positions and compute identity levels\n",
    "\n",
    "ref_genome_func = []\n",
    "idx = 0\n",
    "with ProgressBar(max_value=ref_genome_length) as bar:\n",
    "    for pos in np.arange(ref_genome_length)+1:\n",
    "        F = gft[pos]\n",
    "        if F:\n",
    "            at, name = artificial_genome_feat.loc[[f[2] for f in F]].sort_values(by='annot_plot_order', ascending=False).iloc[0][['annot_type','Name']].values\n",
    "            ref_genome_func.append([pos, at, name])\n",
    "        else:\n",
    "            ref_genome_func.append([pos, 'other', np.nan])\n",
    "        idx += 1\n",
    "        bar.update(idx)\n",
    "\n",
    "ref_genome_func = pd.DataFrame(ref_genome_func, columns=['pos', 'annot_type', 'name'])\n",
    "ref_genome_func.set_index('pos', inplace=True, drop=False)\n",
    "ref_genome_func.loc[0] = np.nan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "116b73d6-c575-4eac-a07c-911480299b04",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "MAF_IDENTITY = []\n",
    "\n",
    "for s, maf in MAF.items():\n",
    "    lift = LIFT[s].copy()\n",
    "    lift['annot_type'] = ref_genome_func.loc[lift['ref_pos']+1, 'annot_type'].values\n",
    "    lift['name'] = ref_genome_func.loc[lift['ref_pos']+1, 'name'].values\n",
    "    s_mugsy = f'{s.replace(\"-\",\"_\")}.mt_pilon'\n",
    "    for (at, name, ai), df in lift.groupby(['annot_type', 'name', 'aln']):\n",
    "        ref_pos = df.index\n",
    "        alt_pos = lift.loc[ref_pos, 'lift']\n",
    "        alleles = [maf[ai][s_mugsy].seq[i] for i in alt_pos]\n",
    "        MAF_IDENTITY.extend([[s, i, at, name, seq] for (i, seq) in zip(ref_pos, alleles)])\n",
    "\n",
    "MAF_IDENTITY = pd.DataFrame(MAF_IDENTITY, columns=['strain','pos','annot_type','name','allele'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "498189eb-617d-4a6d-8590-4603cbb8a912",
   "metadata": {},
   "outputs": [],
   "source": [
    "# exclude missing introns and ORFs from the MAF_IDENTITY\n",
    "intron_presence_dict = GFF.loc[GFF['annot_type'].isin(['orf','intron'])].groupby('strain').apply(lambda x: set(x['Name'])).to_dict()\n",
    "\n",
    "for (s, n), df in MAF_IDENTITY.loc[MAF_IDENTITY['annot_type'].isin(['orf','intron'])].groupby(['strain', 'name']):\n",
    "    #eliminate bi3, because the non-orf portion of the intron is very small in all but SpA and Sc\n",
    "    if (n not in intron_presence_dict[s]) or (n == 'bi3'):\n",
    "        MAF_IDENTITY.drop(df.index, axis=0, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0c6b0cee-c3a4-43c3-9826-22797c52711e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# compute sequence identity per annotation type\n",
    "at_ident = []\n",
    "for (at, name), df in MAF_IDENTITY.groupby(['annot_type','name']):\n",
    "    df = df.pivot_table(index='pos', columns='strain', values='allele', aggfunc=lambda x: x)\n",
    "    for cross, parents in parents_dict.items():\n",
    "        parents = [p.split('.')[-1] for p in parents]\n",
    "        p1, p2 = parents\n",
    "        if all([p in df.columns for p in parents]):\n",
    "            equal = df.loc[(~df[p1].isna()) & (~df[p2].isna())].apply(lambda x: x[p1]==x[p2], axis=1).value_counts()\n",
    "            equal.index = [str(x) for x in equal.index]\n",
    "            for b in ('True', 'False'):\n",
    "                if b not in equal.index:\n",
    "                    equal.loc[b] = 0\n",
    "            at_ident.append([at, name, cross, equal.loc['True'], equal.loc['False']])\n",
    "\n",
    "at_ident = pd.DataFrame(at_ident, columns=['annot_type','name','cross','true','false'])\n",
    "at_ident['identity'] = at_ident['true']/(at_ident['true']+at_ident['false'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d73c12a-2434-437a-b201-11c767f4424d",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Annotation summary\n",
    "## Fig 1C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7de4d078-876d-439f-8962-ab479fd3bb2d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=[10,5])\n",
    "gs = plt.GridSpec(ncols=1, nrows=2, height_ratios=[7,1], hspace=0.7,\n",
    "                 left=0.12, bottom=0.1, right=0.94, top=0.98)\n",
    "\n",
    "at_color_hm = artificial_genome_feat.groupby('annot_type').apply(lambda x: x.iloc[0]['annot_color']).to_dict()\n",
    "\n",
    "ax1 = fig.add_subplot(gs[0])\n",
    "pap_pos = {j:i for i,j in enumerate(pres_abs_poly)}\n",
    "for (s, name, at), df in GFF.loc[GFF['Name'].isin(pres_abs_poly)].groupby(['strain','Name','annot_type']):\n",
    "    #if at in plot_features:\n",
    "    mfc = at_color_hm[at]\n",
    "    mec = 'white'\n",
    "    lw = 0\n",
    "    if mfc == 'white':\n",
    "        mec = 'black'\n",
    "        lw = 1\n",
    "\n",
    "    ax1.scatter(pap_pos[name], parents_order[s], marker='s', s=54, color=mfc, edgecolors=mec, linewidths=lw, zorder=1)\n",
    "\n",
    "for group, (y, dy), fc in zip(['SpC','SpB','SpA','S.cer'], [(0,5), (5,4), (9,2), (11,2)], ['#00008B','#EE0000','#00CD00','0.25']):\n",
    "    rect_spacing = 0.05\n",
    "    Rect = Rectangle((-1, y-0.5+rect_spacing), 65, dy-2*rect_spacing, fc=fc, lw=0, zorder=0, clip_on=False, alpha=0.15)\n",
    "    ax1.add_patch(Rect)\n",
    "    mid = np.mean([y, dy+y])\n",
    "    ax1.text(64.5, mid-0.5, group, color=fc, size=11, fontweight='semibold', fontstyle='italic',\n",
    "             va='center', ha='left', clip_on=False, zorder=1)\n",
    "\n",
    "# add labels to ax1\n",
    "for i, a in enumerate(pres_abs_poly):\n",
    "    fc = at_color_hm[at_dict[a]]\n",
    "    ec = 'white'\n",
    "    tc = 'white'\n",
    "    if fc == 'white':\n",
    "        tc = 'black'\n",
    "        ec = 'black'\n",
    "    if fc == 'limegreen':\n",
    "        tc = 'black'\n",
    "\n",
    "    t = ax1.text(i, 13, pres_abs_poly_alias[a], rotation=90, ha='center', va='top', color=tc, size=7,\n",
    "                 bbox=dict(ec=ec, fc=fc, lw=0.5, boxstyle='square,pad=0.12'), zorder=1)\n",
    "    if a in artificial_genome_feat['Name'].values:\n",
    "        ax1.plot([i,i], [13,16.5], lw=0.5, color='black', zorder=-1, clip_on=False)\n",
    "\n",
    "ax1.set_xticks([])\n",
    "ax1.set_xlim(-1,64)   \n",
    "\n",
    "ax1.set_ylim(-0.5, 12.5)\n",
    "ax1.set_yticks(parents_order)\n",
    "ax1.set_yticklabels(parents_order.index)\n",
    "ax1.invert_yaxis()\n",
    "\n",
    "for i in ['left','bottom','right','top']:\n",
    "    ax1.spines[i].set_visible(False)\n",
    "\n",
    "# plot GFF entries\n",
    "ax2 = fig.add_subplot(gs[1])\n",
    "ax2.arrow(0, 1, ref_genome_length, 0, color='0.9', width=1, head_length=0, head_width=0, zorder=-1)\n",
    "\n",
    "for i in artificial_genome_feat.loc[~artificial_genome_feat['annot_type'].isin(['gc_cluster','other'])].sort_values(by='annot_plot_order', ascending=False).index:\n",
    "    start, end, color, w, z = artificial_genome_feat.loc[i, [3,4,'annot_color','annot_width','annot_plot_order']]\n",
    "    ax2.arrow(start, 1, end-start, 0, color=color, width=w, head_length=0, head_width=0, zorder=z)\n",
    "\n",
    "ax2.set_xlim(0,ref_genome_length)\n",
    "ax2.set_xticks(np.arange(0,83e3,10e3))\n",
    "ax2.set_xticklabels(np.arange(0,83,10))\n",
    "ax2.set_xlabel('kb')\n",
    "ax2.set_ylim(0.5, 1.5)\n",
    "ax2.set_yticks([])\n",
    "\n",
    "for i in ['left','right','top']:\n",
    "    ax2.spines[i].set_visible(False)\n",
    "\n",
    "#link items from one panel to the other\n",
    "for i, a in enumerate(pres_abs_poly):\n",
    "    if a in artificial_genome_feat['Name'].values:\n",
    "        pos = artificial_genome_feat.loc[artificial_genome_feat['Name']==a].iloc[0,3]#[[3,4]].mean()\n",
    "        (x_ax1, y1_ax1), (x_ax1, y2_ax1)  = ax1.transData.transform([(i, 16.5), (i, 13)])\n",
    "        (x_ax1, y1_ax1), (x_ax1, y2_ax1) = ax2.transData.inverted().transform([(x_ax1, y1_ax1), (x_ax1, y2_ax1)])\n",
    "\n",
    "        ax2.plot([pos, x_ax1], [1.5, y1_ax1], lw=0.5, color='black', zorder=-1, clip_on=False)\n",
    "\n",
    "\n",
    "#plt.savefig(f'/home/mathieu/mhenault_landrylab/Publications/mito_ma/resubmission2_GRes/fig/Fig1C.svg', dpi=300)\n",
    "#plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5185b9e-0325-4bcc-81eb-0d9e42502504",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Fig 1A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57461022-821b-4818-95ed-962eea3014c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "#plot crosses scheme\n",
    "fig = plt.figure(figsize=[4.5,4])\n",
    "gs = plt.GridSpec(ncols=1, nrows=1, left=0.2, right=0.77, top=0.98, bottom=0.3)\n",
    "ax = fig.add_subplot(gs[0])\n",
    "\n",
    "cm_hm_cross = ListedColormap([cross_color[cross] for cross in cross_order], 11)\n",
    "hm = np.ndarray([13,13])\n",
    "hm[:] = np.nan\n",
    "\n",
    "for cross in parents_dict:\n",
    "    p1, p2 = [p.split('.')[-1] for p in parents_dict[cross]]\n",
    "    x, y = parents_order[p1], parents_order[p2]\n",
    "    \n",
    "    if cross in ['CC1', 'CC2', 'CC3']:\n",
    "        nrep = 64\n",
    "    elif cross in ['BB1', 'BB2']:\n",
    "        nrep = 48\n",
    "    else:\n",
    "        nrep = 96\n",
    "        \n",
    "    if x > y:\n",
    "        hm[x][y] = cross_order[cross]\n",
    "        ax.text(y+1.6, x+0.5, fr'{cross} ($\\times${nrep})', size=9, color='k', ha='left', va='center', zorder=3)\n",
    "        ax.plot([y+1, y+1.5], [x+0.5, x+0.5], color='k', lw=1, zorder=3)\n",
    "\n",
    "    else:\n",
    "        hm[y][x] = cross_order[cross]\n",
    "        ax.text(x+1.6, y+0.5, fr'{cross} ($\\times${nrep})', size=9, color='k', ha='left', va='center', zorder=3)\n",
    "        ax.plot([x+1, x+1.5], [y+0.5, y+0.5], color='k', lw=1, zorder=2)\n",
    "    \n",
    "P = Polygon(np.array([[0,13,0,0], [13,13,0,13]]).T, fc='white', zorder=1)\n",
    "ax.add_patch(P)\n",
    "\n",
    "for group, (y, dy), fc in zip(['SpC','SpB','SpA','S.cer'], [(0,5), (5,4), (9,2), (11,2)], ['#00008B','#EE0000','#00CD00','0.25']):\n",
    "    rect_spacing = 0.05\n",
    "    \n",
    "    Rect = Rectangle((0, y+rect_spacing), 13, dy-2*rect_spacing, fc=fc, lw=0, zorder=0, clip_on=False, alpha=0.3)\n",
    "    ax.add_patch(Rect)\n",
    "    mid = np.mean([y, dy+y])\n",
    "    ax.text(13.1, mid, group, color=fc, size=11, fontweight='semibold', fontstyle='italic',\n",
    "             va='center', ha='left', clip_on=False, zorder=0)\n",
    "\n",
    "\n",
    "ax.pcolormesh(hm, cmap=cm_hm_cross, zorder=3)\n",
    "ax.set_xlim(0,13)\n",
    "ax.set_xticks(np.arange(13)+0.5)\n",
    "ax.set_xticklabels([])\n",
    "ax.set_yticks(np.arange(13)+0.5)\n",
    "ax.set_yticklabels([])\n",
    "\n",
    "for p in parents_order.index:\n",
    "    if p in ['LL2011_004', 'LL2011_009', 'MSH-604', 'UWOPS-91-202']:\n",
    "        fw = 'bold'\n",
    "    else:\n",
    "        fw = 'normal'\n",
    "    ax.text(parents_order.loc[p]+0.5, 13.5, p, color=parents_color[p], rotation=45, size=10, ha='right', va='top', weight=fw)\n",
    "    ax.text(-0.5, parents_order.loc[p]+0.5, p, color=parents_color[p], ha='right', va='center', weight=fw)\n",
    "\n",
    "ax.set_xlim(0,13)\n",
    "ax.set_ylim(0,13)\n",
    "ax.invert_yaxis()\n",
    "\n",
    "for i in ['right','top']:\n",
    "    ax.spines[i].set_visible(False)\n",
    "\n",
    "\n",
    "#plt.savefig(f'/home/mathieu/mhenault_landrylab/Publications/mito_ma/resubmission2_GRes/fig/Fig1A.svg', dpi=300)\n",
    "#plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8de3a51b-c0af-49e1-bcd1-1af08f212aff",
   "metadata": {},
   "source": [
    "# MtDNA Recombination\n",
    "## Definition of parental marker variants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42d85016-e8cc-4649-b863-5823916b0ada",
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_marker_lift(cross, vma, ps, variant_type):\n",
    "    p_alt, p_ref = np.repeat(np.nan, 2)\n",
    "    \n",
    "    if variant_type == 'single':\n",
    "        vcf = VCF[cross].set_index(VCF[cross]['vma_uid'].values)\n",
    "        pos1, ref, alt = vcf.loc[vma, ['POS','REF','ALT']].values\n",
    "        # correct pos for 0-based\n",
    "        pos1 -= 1    \n",
    "        pos2 = pos1 + len(ref)\n",
    "        # parse which parent has the ref and alt alleles\n",
    "        p_alt, p_ref = np.repeat(np.nan, 2)\n",
    "        for s in parents_dict[cross]:\n",
    "            if ps[1] == s:\n",
    "                p_alt = s.split('.')[-1]\n",
    "            elif ps[0] == s:\n",
    "                p_ref = s.split('.')[-1]\n",
    "                \n",
    "    elif variant_type == 'multi':\n",
    "        vcf = VCF[cross].set_index(VCF[cross]['var_uid'].values)\n",
    "        p_ref = ps[0][2].split('.')[-1]\n",
    "        pos1, real_ref, ref = vcf.loc[ps[0][0], ['POS','REF','ALT']].values\n",
    "        \n",
    "        p_alt = ps[1][2].split('.')[-1]\n",
    "        alt = vcf.loc[ps[1][0], 'ALT']\n",
    "        # correct pos for 0-based\n",
    "        pos1 -= 1    \n",
    "        pos2 = pos1 + len(real_ref)\n",
    "        \n",
    "    else:\n",
    "        raise ValueError('illegal variant type specified')\n",
    "\n",
    "    #if vma position is not present in both liftovers, return np.nan\n",
    "    if all([pos1 in LIFT[p_ref].index,\n",
    "            pos1 in LIFT[p_alt].index,\n",
    "            pos2 in LIFT[p_ref].index,\n",
    "            pos2 in LIFT[p_alt].index]):\n",
    "        \n",
    "        variants = {}\n",
    "        \n",
    "        for s, allele in zip([p_ref, p_alt], [ref, alt]):\n",
    "            \n",
    "            s_mugsy = f'{s.replace(\"-\",\"_\")}.mt_pilon'\n",
    "            maf = MAF[s]\n",
    "            lift = LIFT[s]\n",
    "            ai1, ai2 = lift.loc[[pos1, pos2], 'aln']\n",
    "            if ai1 == ai2:\n",
    "                lift = lift.loc[lift['aln']==ai1]\n",
    "                lift_pos1 = lift.loc[pos1, 'lift']\n",
    "                lift_pos2 = lift.loc[pos2, 'lift']\n",
    "                lift = lift.set_index(lift['lift'])\n",
    "\n",
    "                allele_seq = str(maf[ai1][s_mugsy].seq[lift_pos1:lift_pos2]).replace('-','')\n",
    "                variants[s] = allele_seq == allele\n",
    "        if len(variants) == 2:\n",
    "            return all(variants.values())\n",
    "        else:\n",
    "            return False\n",
    "    \n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc8fad28-27f2-4e7e-a11e-7be170acac5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "PARENTAL_SINGLE = {}\n",
    "PARENTAL_MULTI = {}\n",
    "\n",
    "min_depth = 2\n",
    "\n",
    "for cross in cross_order:\n",
    "    \n",
    "    vcf = VCF[cross]\n",
    "    vcf_melt = VCF_MELT[cross]\n",
    "    p1, p2 = parents_dict[cross]\n",
    "    \n",
    "    # classify parental snps if they can be used to discrimitate parental haplotypes\n",
    "    vcf_melt_p1 = vcf_melt.loc[vcf_melt['filename']==p1]\n",
    "    vcf_melt_p1.index = vcf_melt_p1['var_uid']\n",
    "    vcf_melt_p2 = vcf_melt.loc[vcf_melt['filename']==p2]\n",
    "    vcf_melt_p2.index = vcf_melt_p2['var_uid']\n",
    "\n",
    "    parental_single = {}\n",
    "    parental_multi = {}\n",
    "    for vma, df in vcf.groupby('vma_uid'):\n",
    "        # biallelic snp case\n",
    "        if df.shape[0] == 1:\n",
    "            v = df.index[0]\n",
    "            d1, d2 = np.repeat(np.nan, 2)\n",
    "            \n",
    "\n",
    "            a1 = vcf_melt_p1.loc[v, 'gt']\n",
    "            if a1 == 1:\n",
    "                d1 = vcf_melt_p1.loc[v, 'ao']\n",
    "            if a1 == 0:\n",
    "                d1 = vcf_melt_p1.loc[v, 'ro']\n",
    "\n",
    "            a2 = vcf_melt_p2.loc[v, 'gt']\n",
    "            if a2 == 1:\n",
    "                d2 = vcf_melt_p2.loc[v, 'ao']\n",
    "            if a2 == 0:\n",
    "                d2 = vcf_melt_p2.loc[v, 'ro']\n",
    "\n",
    "            if all([a1 != a2,\n",
    "                    not np.isnan(a1), \n",
    "                    not np.isnan(a2), \n",
    "                    d1>=min_depth, \n",
    "                    d2>=min_depth]) :\n",
    "                parental_single[vma] = {a1:p1, a2:p2}\n",
    "\n",
    "        # multiallelic snp case\n",
    "        else:\n",
    "            v = df.index\n",
    "            A1 = vcf_melt_p1.loc[v, 'gt'].values\n",
    "            A2 = vcf_melt_p2.loc[v, 'gt'].values\n",
    "            if (not np.all(A1 == A2)) and (1 in A1) and (1 in A2):\n",
    "                sub1 = vcf_melt_p1.loc[v]\n",
    "                v1 = sub1.loc[sub1['gt']==1].index[0]\n",
    "                a1 = vcf_melt_p1.loc[v1, 'gt']\n",
    "                d1 = vcf_melt_p1.loc[v1, 'ao']\n",
    "\n",
    "                sub2 = vcf_melt_p2.loc[v]\n",
    "                v2 = sub2.loc[sub2['gt']==1].index[0]\n",
    "                a2 = vcf_melt_p2.loc[v2, 'gt']\n",
    "                d2 = vcf_melt_p2.loc[v2, 'ao']\n",
    "\n",
    "                if all([a1 != a2 or v1 != v2,\n",
    "                       d1>=min_depth,\n",
    "                       d2>=min_depth]):\n",
    "                    parental_multi[vma] = [(v1,a1,p1), (v2,a2,p2)]\n",
    "    \n",
    "    PARENTAL_SINGLE[cross] = parental_single\n",
    "    PARENTAL_MULTI[cross] = parental_multi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3d2ee9b-18bc-4ff6-b789-8eadff2b22b5",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "remove_variants = {}\n",
    "for cross in cross_order:\n",
    "    remove_variants[cross] = {}\n",
    "    for vma, ps in PARENTAL_SINGLE[cross].items():\n",
    "        test = test_marker_lift(cross, vma, ps, 'single')\n",
    "        remove_variants[cross][vma] = test\n",
    "        \n",
    "    for vma, ps in PARENTAL_MULTI[cross].items():\n",
    "        test = test_marker_lift(cross, vma, ps, 'multi')\n",
    "        remove_variants[cross][vma] = test\n",
    "\n",
    "    # analyze parental markers in presence absence polymorphisms\n",
    "\n",
    "    not_conserved = []\n",
    "    parents = [p.split('.')[-1] for p in parents_dict[cross]]\n",
    "    gff = GFF.loc[GFF['strain'].isin(parents)]\n",
    "    for name, df in gff.groupby('Name'):\n",
    "        if not all([p in df['strain'].values for p in parents]):\n",
    "            not_conserved.append(name)\n",
    "    \n",
    "    vcf = VCF[cross].set_index('vma_uid')\n",
    "    for vma in list(PARENTAL_SINGLE[cross])+list(PARENTAL_MULTI[cross]):\n",
    "        pos = vcf.loc[[vma]].iloc[0]['POS']\n",
    "        f = gft[pos]\n",
    "        if f:\n",
    "            name = list(f)[0][2]\n",
    "            name = artificial_genome_feat.loc[name, 'Name']\n",
    "            if name in not_conserved:\n",
    "                remove_variants[cross][vma] = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "193758e8-dc74-4314-9fe9-a885cad1155f",
   "metadata": {},
   "outputs": [],
   "source": [
    "for cross in cross_order:\n",
    "    for vma in remove_variants[cross]:\n",
    "        if remove_variants[cross][vma] == False:\n",
    "            if vma in PARENTAL_SINGLE[cross]:\n",
    "                del PARENTAL_SINGLE[cross][vma]\n",
    "            if vma in PARENTAL_MULTI[cross]:\n",
    "                del PARENTAL_MULTI[cross][vma]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6976151d-9d3a-4cfa-b11f-5ab03dece823",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Classify snps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d9d5cb3-efed-49a8-8247-ba585eb85cf0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# input the coverage depth on nuclear chromosomes\n",
    "idx = 0\n",
    "depth_nuclear = {}\n",
    "with ProgressBar(max_value=ma_strains.loc[ma_strains['cross'].isin(cross_order)].shape[0]) as bar:\n",
    "    \n",
    "    for s in ma_strains.loc[ma_strains['cross'].isin(cross_order)].index:\n",
    "        depth = pd.read_csv(f'/mnt/HDD2/seqdata/depth/{s}/{s}_SpB.depth', sep='\\t', header=None)\n",
    "        depth_median = []\n",
    "        for tig, df in depth.groupby(0):\n",
    "            if tig[:3]=='utg':\n",
    "                depth_median.append(df[2])\n",
    "        depth_median = np.concatenate(depth_median)\n",
    "        depth_nuclear[s] = [np.median(depth_median), np.mean(depth_median), np.std(depth_median), np.quantile(depth_median, 0.1)]\n",
    "        idx += 1\n",
    "        bar.update(idx)\n",
    "\n",
    "depth_nuclear = pd.DataFrame(depth_nuclear).T\n",
    "depth_nuclear.columns = ['median','mean','std','q10']\n",
    "depth_nuclear['thres'] = np.where(depth_nuclear['q10']>=20, depth_nuclear['q10'], 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87f895d7-7979-4874-aba8-c94a18319fb6",
   "metadata": {},
   "outputs": [],
   "source": [
    "#add parental values computed separately\n",
    "for s in ma_strains.loc[ma_strains['cross']=='P'].index:\n",
    "    depth = pd.read_csv(f'/mnt/HDD3/mito_ma/depth_parents/{s.split(\".\")[-1]}.depth', sep='\\t', header=None)\n",
    "    depth_nuclear.loc[s, 'median'] = depth[2].median()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77c23ec7-66ee-47fc-8126-54f4c11e8221",
   "metadata": {},
   "outputs": [],
   "source": [
    "for cross in cross_order:\n",
    "\n",
    "    vcf_melt = VCF_MELT[cross]\n",
    "    vcf_melt['marker'] = False\n",
    "    vcf_melt['parent'] = 'none'\n",
    "\n",
    "    parental_single = PARENTAL_SINGLE[cross]\n",
    "    parental_multi = PARENTAL_MULTI[cross]\n",
    "    \n",
    "    for vma, df in vcf_melt.groupby('vma_uid'):\n",
    "        if vma in parental_single:\n",
    "            for gt,p in parental_single[vma].items():\n",
    "                idx = df.loc[df['gt'] == gt].index\n",
    "                vcf_melt.loc[idx, 'marker'] = True\n",
    "                vcf_melt.loc[idx, 'parent'] = p\n",
    "        if vma in parental_multi:\n",
    "            for (v, gt, p) in parental_multi[vma]:\n",
    "                df1 = df.loc[df['var_uid']==v]\n",
    "                idx = df1.loc[df1['gt'] == gt].index\n",
    "                vcf_melt.loc[idx, 'marker'] = True\n",
    "                vcf_melt.loc[idx, 'parent'] = p\n",
    "                \n",
    "    # add whole-genome depth information\n",
    "    for s, df in vcf_melt.groupby('filename'):\n",
    "        # exclude parents\n",
    "        if ma_strains.loc[s, 'cross'] == cross:\n",
    "            vcf_melt.loc[df.index, 'depth_nuclear'] = depth_nuclear.loc[s,'thres']\n",
    "            \n",
    "    #add binary filter for whether support is higher than nuclear depth\n",
    "    for gt, df in vcf_melt.groupby('gt'):\n",
    "        if gt == 1:\n",
    "            vcf_melt.loc[df.index, 'higher'] = df['ao'] >= df['depth_nuclear']\n",
    "        if gt == 0:\n",
    "            vcf_melt.loc[df.index, 'higher'] = df['ro'] >= df['depth_nuclear']\n",
    "    \n",
    "    vcf_melt['line'] = ma_strains.loc[vcf_melt['filename'], 'strain'].values\n",
    "    vcf_melt['passage'] = ma_strains.loc[vcf_melt['filename'], 'passage'].values\n",
    "    \n",
    "    VCF_MELT[cross] = vcf_melt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8de021cb-9ea1-4a63-8a0d-e92b9ec2b985",
   "metadata": {},
   "outputs": [],
   "source": [
    "# make a dictionary of the markers for each cross\n",
    "MARKERS = {}\n",
    "\n",
    "for cross in cross_order:\n",
    "    vcf_melt = VCF_MELT[cross]\n",
    "    vcf_melt = vcf_melt.loc[vcf_melt['marker']]\n",
    "    MARKERS[cross] = sorted(set(vcf_melt['vma_uid']))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61050170-940f-41b3-81c1-1f12af392aae",
   "metadata": {},
   "source": [
    "## Determine clonal mt haplotypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1cc87d8-111a-47da-9d66-bfb49e5d7ac0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# compute distance between haplotypes within lines based on markers\n",
    "distance = []\n",
    "for cross in cross_order:\n",
    "    parents_mapping_dict = {j:i for i,j in enumerate(parents_dict[cross])}\n",
    "    vcf_melt = VCF_MELT[cross]\n",
    "    vcf_melt = vcf_melt.loc[(vcf_melt['marker']) & (vcf_melt['higher'])]\n",
    "    vcf_melt = vcf_melt.pivot_table(index='var_uid', columns='filename', values='parent', aggfunc=lambda x: x)\n",
    "    for line, df in ma_strains.loc[(ma_strains['cross']==cross) &\n",
    "                                   (ma_strains['filename'].isin(vcf_melt.columns)) & \n",
    "                                   (ma_strains['identity_filter'])].sort_values(by='passage').groupby('strain'):\n",
    "\n",
    "        profiles = vcf_melt.loc[:, df['filename']]\n",
    "        if profiles.shape[1] > 1:\n",
    "            for (i,j) in itertools.combinations(profiles.columns, 2):\n",
    "                u = profiles[i].replace(parents_mapping_dict).values\n",
    "                v = profiles[j].replace(parents_mapping_dict).values\n",
    "\n",
    "                d = nan_distance(u,v)\n",
    "                distance.append([cross, line, i, j, 1-d])\n",
    "        elif profiles.shape[1] == 1:\n",
    "            fn = profiles.columns[0]\n",
    "            distance.append([cross, line, fn, fn, 1])\n",
    "\n",
    "distance = pd.DataFrame(distance, columns=['cross','line','filename1','filename2','dist'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f56c5303-6357-4d52-9c82-5a6f45be9acc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# get lines to examine manually\n",
    "mthap_manual_examination = []\n",
    "ma_strains['mt_haplotype'] = 'none'\n",
    "for s, df in distance.groupby('line'):\n",
    "    if df.shape[0] == 1:\n",
    "        fn1 = df.iloc[0]['filename1']\n",
    "        fn2 = df.iloc[0]['filename2']\n",
    "        if df.iloc[0]['dist'] >= 0.95:\n",
    "            ma_strains.loc[fn1, 'mt_haplotype'] = 'clone'\n",
    "            ma_strains.loc[fn2, 'mt_haplotype'] = s\n",
    "        else:\n",
    "            ma_strains.loc[fn1, 'mt_haplotype'] = fn1.split('.')[-1]\n",
    "            ma_strains.loc[fn2, 'mt_haplotype'] = fn2.split('.')[-1]\n",
    "    else:\n",
    "        mthap_manual_examination.append(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "76c7b6d0-acf4-40ca-88ca-bf59dcf4e34e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# manual examination\n",
    "fig, axes = plt.subplots(ncols=3, nrows=3, figsize=[10,10])\n",
    "for (i,j), s in zip(itertools.product(range(3), range(3)), mthap_manual_examination):\n",
    "    ax = axes[i,j]\n",
    "    dat = distance.loc[distance['line']==s].copy()\n",
    "    dat['s1'] = dat['filename1'].apply(lambda x: ' '.join([x.split('.')[i] for i in (0,-1)]))\n",
    "    dat['s2'] = dat['filename2'].apply(lambda x: ' '.join([x.split('.')[i] for i in (0,-1)]))\n",
    "    sns.heatmap(dat.pivot_table(index='s1', columns='s2', values='dist'), vmin=0.9, vmax=1, cmap='bwr', ax=ax)\n",
    "    ax.set_title(s)\n",
    "\n",
    "plt.tight_layout()\n",
    "#plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85cc6904-64d7-47d7-a1dd-8c306f2b41fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "# manual examination of allele ratios\n",
    "cross = 'BA1'\n",
    "vcf_melt = VCF_MELT[cross]\n",
    "test = {}\n",
    "\n",
    "for s, dat in vcf_melt.groupby('filename'):\n",
    "    \n",
    "    ratios = np.where(dat['gt']==0, dat['r_ratio'], dat['a_ratio'])\n",
    "    test[s] = ratios[(ratios>0) & (ratios<0.9)].shape[0]/ratios.shape[0]\n",
    "\n",
    "    c = 'black'\n",
    "    z = 1\n",
    "    if s == 'HI.4803.002.N703---N508.B2_P35':\n",
    "        c = 'red'\n",
    "        z = 10\n",
    "\n",
    "    plt.plot(np.sort(ratios), np.linspace(0,1,ratios.shape[0]), label=s, c=c, alpha=0.3, zorder=z)\n",
    "\n",
    "plt.title(cross)\n",
    "plt.xlim(0.8,1)\n",
    "plt.ylim(0,0.4)\n",
    "#plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3665108-579c-4bc7-bf01-000e03b5a349",
   "metadata": {},
   "outputs": [],
   "source": [
    "# low allelic ratios to exclude\n",
    "low_ratio = ['NS.1250.001.N704---N507.J40_P35',\n",
    "             'HI.4802.003.N711---N503.I7_P1',\n",
    "             'HI.4803.001.N704---N504.I25_P35',\n",
    "             'HI.4803.001.N708---N504.D85_P35',\n",
    "             'HI.4803.002.N703---N508.B2_P35',\n",
    "             'HI.4803.001.N708---N506.B40_P35',\n",
    "             'HI.4803.001.N706---N506.F81_P35']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec73d877-3c96-497c-a5bf-29fb927fe6c3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# manually process lines for which there is more than P1 and P35\n",
    "ma_strains.loc[ma_strains['strain'].isin(mthap_manual_examination), 'mt_haplotype'] = 'clone'\n",
    "ma_strains.loc['NS.1250.002.N704---N504.B32_P35', 'mt_haplotype'] = 'B32'\n",
    "ma_strains.loc['NS.1249.002.N712---N508.B40_P16', 'mt_haplotype'] = 'B40_P16'\n",
    "ma_strains.loc['HI.4803.001.N708---N506.B40_P35', 'mt_haplotype'] = 'B40_P35_HI'\n",
    "ma_strains.loc['NS.1250.002.N704---N507.B40_P35', 'mt_haplotype'] = 'B40_P35_NS'\n",
    "ma_strains.loc['HI.4803.003.N701---N502.B49_P35', 'mt_haplotype'] = 'B49'\n",
    "ma_strains.loc['NS.1249.002.N710---N504.B55_P1', 'mt_haplotype'] = 'B55_P1'\n",
    "ma_strains.loc['NS.1250.002.N705---N508.B55_P35', 'mt_haplotype'] = 'B55_P35'\n",
    "ma_strains.loc['HI.4803.002.N712---N504.D36_P35', 'mt_haplotype'] = 'D36'\n",
    "ma_strains.loc['HI.4803.003.N703---N508.F38_P25', 'mt_haplotype'] = 'F38'\n",
    "ma_strains.loc['NS.1250.001.N711---N503.F43_P35', 'mt_haplotype'] = 'F43'\n",
    "ma_strains.loc['NS.1250.002.N709---N508.F57_P35', 'mt_haplotype'] = 'F57'\n",
    "# manually switch clonal haplotypes\n",
    "ma_strains.loc['HI.4802.002.N712---N517.A62_P1', 'mt_haplotype'] = 'A62'\n",
    "ma_strains.loc['HI.4803.003.N703---N502.A62_P35', 'mt_haplotype'] = 'clone'\n",
    "ma_strains.loc['HI.4802.002.N702---N508.F3_P1', 'mt_haplotype'] = 'F3'\n",
    "ma_strains.loc['HI.4803.003.N705---N505.F3_P35', 'mt_haplotype'] = 'clone'\n",
    "ma_strains.loc['HI.4802.002.N707---N502.C46_P1', 'mt_haplotype'] = 'C46'\n",
    "ma_strains.loc['HI.4803.003.N711---N505.C46_P35', 'mt_haplotype'] = 'clone'\n",
    "ma_strains.loc['NS.1249.002.N701---N506.J29_P1', 'mt_haplotype'] = 'J29'\n",
    "ma_strains.loc['NS.1250.001.N703---N503.J29_P35', 'mt_haplotype'] = 'clone'\n",
    "ma_strains.loc['NS.1249.001.N707---N505.J15_P1', 'mt_haplotype'] = 'J15'\n",
    "ma_strains.loc['NS.1250.002.N703---N503.J15_P35', 'mt_haplotype'] = 'clone'\n",
    "ma_strains.loc['NS.1249.002.N703---N508.J54_P1', 'mt_haplotype'] = 'J54'\n",
    "ma_strains.loc['NS.1250.001.N712---N504.J54_P35', 'mt_haplotype'] = 'clone'\n",
    "ma_strains.loc['NS.1249.001.N712---N517.J64_P1', 'mt_haplotype'] = 'J64'\n",
    "ma_strains.loc['NS.1250.002.N712---N502.J64_P35', 'mt_haplotype'] = 'clone'\n",
    "ma_strains.loc['NS.1249.001.N712---N507.L5_P1', 'mt_haplotype'] = 'L5'\n",
    "ma_strains.loc['NS.1250.002.N706---N503.L5_P35', 'mt_haplotype'] = 'clone'\n",
    "ma_strains.loc['NS.1249.002.N705---N504.L46_P1', 'mt_haplotype'] = 'L46'\n",
    "ma_strains.loc['NS.1250.002.N711---N517.L46_P35', 'mt_haplotype'] = 'clone'\n",
    "ma_strains.loc['HI.4802.001.N707---N507.B54_P1', 'mt_haplotype'] = 'B54'\n",
    "ma_strains.loc['HI.4803.003.N703---N505.B54_P35', 'mt_haplotype'] = 'clone'\n",
    "ma_strains.loc['HI.4802.001.N711---N504.E34_P1', 'mt_haplotype'] = 'E34'\n",
    "ma_strains.loc['HI.4803.001.N705---N505.E34_P35', 'mt_haplotype'] = 'clone'\n",
    "ma_strains.loc['HI.4802.003.N705---N505.E37_P1', 'mt_haplotype'] = 'E37'\n",
    "ma_strains.loc['HI.4803.002.N707---N508.E37_P35', 'mt_haplotype'] = 'clone'\n",
    "ma_strains.loc['HI.4802.001.N703---N503.C87_P1', 'mt_haplotype'] = 'C87'\n",
    "ma_strains.loc['HI.4803.003.N707---N502.C87_P35', 'mt_haplotype'] = 'clone'\n",
    "ma_strains.loc['HI.4802.001.N707---N508.F15_P1', 'mt_haplotype'] = 'F15'\n",
    "ma_strains.loc['HI.4803.001.N710---N503.F15_P35', 'mt_haplotype'] = 'clone'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc96efd4-3f59-44b9-a65f-05087273847e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# combine info of clonal mthap with ones with low allele support ratio\n",
    "ma_strains['mthap_filter'] = np.where((ma_strains['mt_haplotype'].isin(['clone','none']))\n",
    "                                      | (ma_strains['filename'].isin(low_ratio)), False, True)\n",
    "ma_strains['mtdel_filter'] = np.where((ma_strains['mt_haplotype']=='none')\n",
    "                                      | (ma_strains['filename'].isin(low_ratio)), False, True)\n",
    "ma_strains['mt_hap_del'] = np.nan\n",
    "for (s,p), df in ma_strains.loc[ma_strains['mtdel_filter']].groupby(['strain','passage']):\n",
    "    if df.shape[0] == 1:\n",
    "        ma_strains.loc[df.index, 'mt_hap_del'] = f'{s}_P{p}'\n",
    "    else:\n",
    "        ma_strains.loc[df.index, 'mt_hap_del'] = np.where(df['mt_haplotype']=='clone', df['filename'].apply(lambda x: x.split('.')[-1]), df['mt_haplotype'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d9f9910-437f-434f-a153-aca422a455cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# add mt_hap_del ids to lines with no mtDNA variants ('none' in mt_haplotype)\n",
    "df = ma_strains.loc[(ma_strains['mt_haplotype']=='none')\n",
    "               & (ma_strains['identity_filter']==True)\n",
    "               & (ma_strains['cross'].isin(cross_order))]\n",
    "ma_strains.loc[df.index, 'mt_hap_del'] = df['strain_passage']\n",
    "ma_strains.loc[df.index, 'mtdel_filter'] = True\n",
    "\n",
    "df = ma_strains.loc[ma_strains['cross']=='P']\n",
    "ma_strains.loc[df.index, 'mt_hap_del'] = df['strain']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2624c90-1c85-4fa9-bdc2-b0d0abc8e01b",
   "metadata": {},
   "source": [
    "## Final export of MA strains metadata with haplotype info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ac75073-257a-4671-8334-c994af8377a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "#final export\n",
    "#ma_strains.to_csv('/mnt/HDD3/mito_ma/script/ma_strains_mthap.tsv', sep='\\t')\n",
    "ma_strains = pd.read_csv('/mnt/HDD3/mito_ma/script/ma_strains_mthap.tsv', sep='\\t', index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4f93fef7-a342-490b-aec3-3d11d91f2cf2",
   "metadata": {},
   "outputs": [],
   "source": [
    "strains_mthap = ma_strains.loc[ma_strains['mthap_filter'], 'filename']\n",
    "strains_mtdel = ma_strains.loc[ma_strains['mtdel_filter'], 'filename']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd4a6773-f169-4358-a8a4-b15802ca065c",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Sort lines by similarity of marker variants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78d04e99-97d4-4403-baca-a0d78dd10ee2",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# sort lines by marker variants profile similarity\n",
    "STRAIN_ORDER_MARKERS = {}\n",
    "\n",
    "for cross in cross_order:\n",
    "\n",
    "    strains_to_include = ma_strains.loc[(ma_strains['mthap_filter']) & \n",
    "                                        (ma_strains['cross']==cross), 'filename']\n",
    "    parents_mapping_dict = {j:i for i,j in enumerate(parents_dict[cross])}\n",
    "    vcf_melt = VCF_MELT[cross]\n",
    "    vcf_melt = vcf_melt.loc[(vcf_melt['marker']) & \n",
    "                            (vcf_melt['vma_uid'].isin(MARKERS[cross])) & \n",
    "                            (vcf_melt['filename'].isin(strains_to_include))]\n",
    "    vcf_melt = vcf_melt.pivot_table(index='var_uid', columns='filename', values='parent', aggfunc=lambda x: x).replace(parents_mapping_dict)\n",
    "\n",
    "    dendro = hierarchy.dendrogram(hierarchy.linkage(vcf_melt.T.values, metric=nan_distance), no_plot=True)\n",
    "    strain_order = [vcf_melt.columns[i] for i in dendro['leaves']]\n",
    "\n",
    "    STRAIN_ORDER_MARKERS[cross] = strain_order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03b292bf-362c-4b4a-bbc8-049d0e37b747",
   "metadata": {},
   "outputs": [],
   "source": [
    "#manually flip the order of some crosses\n",
    "for cross in ['CC2','CC3','BB1','BC2','BA1','BSc1']:\n",
    "    STRAIN_ORDER_MARKERS[cross] = STRAIN_ORDER_MARKERS[cross][::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ea612c7-582d-4c85-984d-977b8023b140",
   "metadata": {},
   "source": [
    "## Table S3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fb331931-d8d8-47a6-b031-824af21a60bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "consistent_hap = []\n",
    "for (cross, s), df in ma_strains.loc[(ma_strains['passage'].isin([1, 35])) &\n",
    "                                    (ma_strains['cross'].isin(cross_order))].sort_values(by='passage').groupby(['cross','strain']):\n",
    "    if df.shape[0] == 2:\n",
    "        if np.all(df['passage'].values == [1, 35]):\n",
    "            if 'clone' in df['mt_haplotype'].values:\n",
    "                cst = 'consistent'\n",
    "            else:\n",
    "                cst = 'inconsistent'\n",
    "            consistent_hap.append([cross, s, cst])\n",
    "consistent_hap = pd.DataFrame(consistent_hap, columns=['cross', 'strain', 'consistent'])\n",
    "cons_hap_pivot = consistent_hap.value_counts(['cross','consistent'], sort=False).rename('count').reset_index().\\\n",
    "pivot_table(index='cross', columns='consistent', values='count', aggfunc=lambda x: x).loc[cross_order]\n",
    "cons_hap_pivot['percent_inconsistent'] = cons_hap_pivot['inconsistent']/(cons_hap_pivot['consistent']+cons_hap_pivot['inconsistent'])*100\n",
    "#cons_hap_pivot.to_csv('/mnt/HDD3/mito_ma/results/cons_hap_pivot.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66fdfad4-1ab4-46b7-85e5-08f839830007",
   "metadata": {},
   "source": [
    "## Fig S3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16cccf4c-62cf-4ab5-98c7-9a361b66403a",
   "metadata": {},
   "outputs": [],
   "source": [
    "#bins = np.linspace(0, 0.5, 101)\n",
    "bins = [0, 0.005, 0.05, 0.5]\n",
    "\n",
    "minor_af_hist = []\n",
    "\n",
    "for (cross, p), df in ma_strains.loc[(ma_strains['identity_filter']==True) &\n",
    "                                     (ma_strains['cross'].isin(cross_order)) &\n",
    "                                     (ma_strains['passage'].isin([1,35]))].groupby(['cross', 'passage']):\n",
    "\n",
    "\n",
    "    vcf_melt = VCF_MELT[cross]\n",
    "    vcf_melt = vcf_melt[(vcf_melt['higher']==True) &\n",
    "                        (~vcf_melt['ratio'].isna())].set_index('filename')\n",
    "\n",
    "    S = df.index\n",
    "    S = [s for s in S if s in vcf_melt.index]\n",
    "    \n",
    "\n",
    "    ratio = vcf_melt.loc[S, ['a_ratio', 'r_ratio']].min(axis=1)\n",
    "    h = np.histogram(ratio, bins=bins)[0]/ratio.shape[0]\n",
    "\n",
    "    h = pd.Series(h, index=[f'[{bins[i]}, {bins[i+1]})' for i in range(3)], name=cross).rename('freq').reset_index()\n",
    "    h['cross'] = cross\n",
    "    h['passage'] = p\n",
    "    minor_af_hist.append(h)\n",
    "        \n",
    "minor_af_hist = pd.concat(minor_af_hist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6aebff71-34bb-44f3-bc6d-7bcd5ccf2a40",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=[7,7])\n",
    "gs = plt.GridSpec(ncols=4, nrows=3, hspace=0.8, wspace=1,\n",
    "                  bottom=0.12, right=0.97, top=0.96, left=0.12)\n",
    "cross_ax = dict(zip(cross_order, itertools.product(range(3), range(4))))\n",
    "passage_color_dict={1:'0.6', 35:'k'}\n",
    "\n",
    "for cross in cross_order:\n",
    "    \n",
    "    ax = fig.add_subplot(gs[cross_ax[cross]])\n",
    "    df = minor_af_hist.loc[minor_af_hist['cross']==cross]\n",
    "    \n",
    "    sns.barplot(x='index', y='freq', hue='passage', palette=passage_color_dict, data=df)\n",
    "    ax.legend_.remove()\n",
    "    plt.xticks(rotation=45, ha='right')\n",
    "    \n",
    "    ax.set_xlabel('')\n",
    "    ax.set_ylim(0, 0.85)\n",
    "    ax.set_ylabel('proportion of minor\\nallele frequencies')\n",
    "    ax.set_title(cross)\n",
    "    \n",
    "ax = fig.add_axes([0.75, 0.18, 0.15, 0.08])\n",
    "ax.axis('off')\n",
    "legend_elms = [Line2D([0], [0], color='white', marker='s', ms=9, mfc=mfc, label=l) for (l, mfc) in zip(['initial timepoint', 'final timepoint'], ['0.6', 'k'])]\n",
    "ax.legend(handles=legend_elms, loc=3, bbox_to_anchor=[0,0], frameon=False)\n",
    "\n",
    "sns.despine()\n",
    "#plt.savefig('/home/mathieu/mhenault_landrylab/Publications/mito_ma/resubmission2_GRes/fig/allele_freq.svg', dpi=300)\n",
    "#plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3523a19b-3424-412f-98cf-1bdfaba5f5a6",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Define tracts of parental ancestry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "802d6de9-8b0f-4870-a4c0-0b47bf1c56b5",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# find tracts of parental ancestry\n",
    "def make_tracts(cross, markers):\n",
    "\n",
    "    TRACTS = []\n",
    "\n",
    "    vcf = VCF[cross]\n",
    "    vcf_melt = VCF_MELT[cross]\n",
    "    vcf_melt = vcf_melt.loc[(vcf_melt['marker']) & \n",
    "                            (vcf_melt['higher']) &\n",
    "                            (vcf_melt['vma_uid'].isin(markers))]\n",
    "\n",
    "    for s, df in vcf_melt.sort_values(by='POS').groupby('filename'):\n",
    "\n",
    "        tracts = []\n",
    "        latest = 'init'\n",
    "        new_tract = []\n",
    "\n",
    "        for i,idx in enumerate(df.index):\n",
    "            call = df.loc[idx, 'parent']\n",
    "            if call != latest:\n",
    "                #first, go one further and see if it matches the latest\n",
    "                if i < df.shape[0]-1:\n",
    "                    next_idx = df.index[i+1]\n",
    "                    next_call = df.loc[next_idx, 'parent']\n",
    "                    if next_call == latest:\n",
    "                        continue\n",
    "\n",
    "                #if there is an active new tract, dump it first\n",
    "                if len(new_tract) > 0:\n",
    "                    tracts.append(new_tract)\n",
    "                #define new tract with the first index in\n",
    "                new_tract = [idx]\n",
    "                #update latest \n",
    "                latest = call\n",
    "\n",
    "            else:\n",
    "                new_tract.append(idx)\n",
    "                latest = call\n",
    "                if i == df.shape[0]-1:\n",
    "                    tracts.append(new_tract)\n",
    "\n",
    "        tracts_format = []\n",
    "        for t in tracts:\n",
    "            if len(t) > 1:\n",
    "                pos = df.loc[t, 'POS'].values\n",
    "                call = list(set(df.loc[t, 'parent']))[0]\n",
    "                tracts_format.append([cross, s, pos.min(), pos.max(), call])\n",
    "\n",
    "        TRACTS.extend(tracts_format)\n",
    "\n",
    "    TRACTS = pd.DataFrame(TRACTS, columns=['cross','strain','start','end','parent'])\n",
    "\n",
    "    # circularize tracts\n",
    "    for s, df in TRACTS.sort_values(by='start').groupby('strain'):\n",
    "        if df.shape[0] == 1:\n",
    "            TRACTS.loc[df.index[0], 'start'] = 0\n",
    "            TRACTS.loc[df.index[0], 'end'] = ref_genome_length\n",
    "        if df.shape[0] > 2:\n",
    "            first = df.index[0]\n",
    "            last = df.index[-1]\n",
    "\n",
    "            if df.loc[first, 'parent'] == df.loc[last, 'parent']:\n",
    "                TRACTS.loc[first, 'start'] = df.loc[last, 'start']\n",
    "                TRACTS.drop(last, inplace=True)\n",
    "    return TRACTS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be0be409-e9da-4138-af9a-133b98d78625",
   "metadata": {},
   "outputs": [],
   "source": [
    "TRACTS = []\n",
    "for cross in cross_order:\n",
    "    tracts = make_tracts(cross, MARKERS[cross])\n",
    "    TRACTS.append(tracts)\n",
    "TRACTS = pd.concat(TRACTS).reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8377464b-1e6d-4eff-9363-5242448ade9b",
   "metadata": {},
   "source": [
    "## Haplotype paintings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c1f2f58e-8f4b-4aad-bd21-8db8033d3a1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_rearrangement_SpA():\n",
    "    arcs = [(21e3,47e3), (57.5e3,65.5e3), (60.5e3,26e3), (46.5e3,69e3)]\n",
    "    y_offset = -0.1\n",
    "    for a in arcs:\n",
    "        al = np.abs(a[0]-a[1])\n",
    "        a = Arc((np.mean(a), 1.7+y_offset), al, 5e-5*al, theta1=0, theta2=180, lw=1, alpha=0.5, color='k', clip_on=False)\n",
    "        ax.add_artist(a)\n",
    "        y_offset += 0.05\n",
    "\n",
    "    segments = [(0,21e3), (47e3,57.5e3), (65.5e3, 60.5e3), (26e3,46.5e3), (69e3, len(artificial_genome.seq))]\n",
    "    y_offset = -0.1\n",
    "    for seg in segments:\n",
    "        if seg[0] < seg[1]:\n",
    "            color = 'k'\n",
    "            start = min(seg)\n",
    "            end = max(seg)\n",
    "        else:\n",
    "            color='r'\n",
    "            start = max(seg)\n",
    "            end = min(seg)\n",
    "        \n",
    "\n",
    "        ax.arrow(start, 1.7+y_offset, end-start, 0, color=color, width=0.1, head_length=1e3, length_includes_head=True, head_width=0.2, zorder=z)\n",
    "        y_offset += 0.05"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95a75d4b-c923-4955-8e51-96fc256549ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "def transform_rad(x, padding_rad=1.28):\n",
    "    return (x/(ref_genome_length*padding_rad))*2*np.pi"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fae90b1b-2e82-42fe-a726-f66e0d966aa1",
   "metadata": {},
   "source": [
    "## Fig 2A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a2d50a9-0af8-4844-80ab-7bdd522d1042",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=[10,6])\n",
    "gs = plt.GridSpec(ncols=3, nrows=2)\n",
    "\n",
    "inc = 0.05\n",
    "lw = 0.8\n",
    "pad_y = 0.015\n",
    "pad_x = 4/7*pad_y\n",
    "pad_lines = 5\n",
    "plot_data = True\n",
    "\n",
    "for cross_type, rect in zip([['CC1','CC2','CC3'],\n",
    "                             ['BB1','BB2'],\n",
    "                             ['BC1','BC2'],\n",
    "                             ['BA1','BA2'],\n",
    "                             ['BSc1','BSc2']],\n",
    "                                    \n",
    "                            [(0, 1/4, 3/7, 3/4),\n",
    "                             (3/7, 1/2, 2/7,1/2),\n",
    "                             (5/7, 1/2, 2/7,1/2),\n",
    "                             (3/7, 0, 2/7,1/2),\n",
    "                             (5/7, 0, 2/7,1/2)]):\n",
    "    \n",
    "    #apply padding\n",
    "    rect = np.array(rect)+np.array([pad_x, pad_y, -2*pad_x, -2*pad_y])\n",
    "    \n",
    "    ax = fig.add_axes(rect, projection='polar')\n",
    "    \n",
    "\n",
    "    ax2 = fig.add_axes(rect)\n",
    "    ax2.axis('off')\n",
    "    ax2.set_xlim(0,10)\n",
    "    ax2.set_ylim(0,10)\n",
    "    \n",
    "\n",
    "    cross_ybar = {}\n",
    "    y = 0\n",
    "    \n",
    "    total_s = sum([len(STRAIN_ORDER_MARKERS[cross]) for cross in cross_type]) + pad_lines*(len(cross_type)-1)\n",
    "    \n",
    "\n",
    "    for cross in cross_type:\n",
    "        \n",
    "        y_start_cross = y\n",
    "        \n",
    "        for s in STRAIN_ORDER_MARKERS[cross]:\n",
    "            if plot_data:\n",
    "                tracts = TRACTS.loc[TRACTS['strain']==s]\n",
    "\n",
    "                for i in tracts.index:\n",
    "                    (start, end, parent) = tracts.loc[i, ['start','end','parent']]\n",
    "                    start, end = [transform_rad(x) for x in (start, end)]\n",
    "                    parent = parent.split('.')[-1]\n",
    "                    c = parents_color[parent]\n",
    "\n",
    "                    if start < end:\n",
    "                        X = np.arange(start, end, inc)\n",
    "                        Y = np.repeat(y, X.shape[0])\n",
    "                        ax.plot(X, Y, color=c, lw=lw)\n",
    "                    elif start > end:\n",
    "                        X = np.arange(start, transform_rad(ref_genome_length), inc)\n",
    "                        Y = np.repeat(y, X.shape[0])\n",
    "                        ax.plot(X, Y, color=c, lw=lw)\n",
    "                        X = np.arange(0, end, inc)\n",
    "                        Y = np.repeat(y, X.shape[0])\n",
    "                        ax.plot(X, Y, color=c, lw=lw)\n",
    "            y += 1\n",
    "        \n",
    "        cross_ybar[cross] = [y_start_cross, y]\n",
    "        \n",
    "        y += pad_lines\n",
    "\n",
    "    # plot GFF entries\n",
    "    \n",
    "    R = Rectangle((0, y), transform_rad(ref_genome_length), 10, fc='0.9', lw=0, zorder=-1)\n",
    "    ax.add_patch(R)\n",
    "    \n",
    "    for i in artificial_genome_feat.loc[~artificial_genome_feat['annot_type'].isin(['gc_cluster','other'])].sort_values(by='annot_plot_order', ascending=False).index:\n",
    "        start, end, color, w, z = artificial_genome_feat.loc[i, [3,4,'annot_color','annot_width','annot_plot_order']]\n",
    "        start, end = [transform_rad(x) for x in (start, end)]\n",
    "        w *= 10\n",
    "        R = Rectangle((start, y+(10-w)/2), end-start, w, fc=color, lw=0, zorder=z)\n",
    "        ax.add_patch(R)\n",
    "        \n",
    "    y += 3*pad_lines\n",
    "    \n",
    "    for X in np.arange(0,ref_genome_length, 1e4):\n",
    "        x = transform_rad(X)\n",
    "        ax.scatter(x, y, marker='o', s=4, color='k')\n",
    "        if x <= np.pi:\n",
    "            ha='left'\n",
    "        else:\n",
    "            ha='right'\n",
    "        if -1*np.pi/2 <= x < np.pi/2:\n",
    "            va = 'bottom'\n",
    "        else:\n",
    "            va = 'top'\n",
    "        ax.text(x, y+pad_lines, f'{X*1e-3:.0f}', size=8, va=va, ha=ha, color='k')\n",
    "    \n",
    "    ax.set_theta_offset(.5*np.pi)\n",
    "    ax.set_theta_direction(-1)\n",
    "    ax.grid(False)\n",
    "    \n",
    "    ax.set_yticks([])\n",
    "    ax.set_ylim(np.array([0, y]) + np.repeat(total_s,2)*np.array([-0.3, 0.1]))\n",
    "    \n",
    "    ax.spines['polar'].set_visible(False)\n",
    "    ax.set_xticks([])\n",
    "    \n",
    "    \n",
    "    T1 = ax.transData.transform\n",
    "    T2 = ax2.transData.inverted().transform\n",
    "    \n",
    "    for cross in cross_type:\n",
    "        p1, p2 = [p.split('.')[-1] for p in parents_dict[cross]]\n",
    "        ybar = np.array(cross_ybar[cross])*0.93\n",
    "        (x1, y1), (x2, y2) = T2(T1([(0, yi) for yi in ybar]))\n",
    "        dy = y2-y1\n",
    "        if cross in ['CC1', 'CC2', 'CC3']:\n",
    "            dx = -0.5\n",
    "        else:\n",
    "            dx = -0.7\n",
    "        R = Rectangle((x1+0.1*dx, y1), dx, dy, fc=cross_color[cross], lw=0)\n",
    "        ax2.add_patch(R)\n",
    "        ax2.text(x1+0.6*dx, y1+0.5*dy, cross, color='w', rotation=90, ha='center', va='center')\n",
    "        \n",
    "        ax2.scatter([3.9, 3.9], [y1+0.7*dy, y1+0.3*dy], marker='s', s=42, color=[parents_color[p] for p in [p1, p2]])\n",
    "        ax2.text(3.6, y1+0.7*dy, fr'{p1} (${parents_group[p1]}$)', size=8, ha='right', va='center')\n",
    "        ax2.text(3.6, y1+0.3*dy, fr'{p2} (${parents_group[p2]}$)', size=8, ha='right', va='center')\n",
    "\n",
    "# plot legend\n",
    "ax = fig.add_axes((0, 0, 3/7, 1/4))\n",
    "ax.axis('off')\n",
    "legend_elms = []\n",
    "for at in annot_type_order:\n",
    "    if at != 'gc_cluster':\n",
    "        l = annot_type_alias[at]\n",
    "        fc = annot_type_color[at]\n",
    "        lw = 0\n",
    "        if fc == 'white':\n",
    "            lw = 1\n",
    "        legend_elms.append(Line2D([0], [0], color='w', marker='s', ms=9, mfc=fc, mec='black', mew=lw, label=l))\n",
    "ax.legend(handles=legend_elms, ncol=3, loc=9, bbox_to_anchor=(0.5, 0.8), frameon=False,\n",
    "         borderpad=0.0, labelspacing=0.2, handlelength=0.3, columnspacing=1.5)\n",
    "\n",
    "\n",
    "#plt.savefig(f'/home/mathieu/mhenault_landrylab/Publications/mito_ma/resubmission2_GRes/fig/Fig2A.svg', dpi=300)\n",
    "#plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3d530ec-77f3-4541-b64d-dcd7237a83e7",
   "metadata": {},
   "source": [
    "## Recombination breakpoints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ca3f836-6c90-44fb-9c06-7a93abce96e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "bins = pd.interval_range(start=0, end=ref_genome_length+1, freq=250, closed='left')\n",
    "\n",
    "breakpoints = []\n",
    "\n",
    "for cross, tracts in TRACTS.loc[TRACTS['strain'].isin(strains_mthap)].groupby('cross'):\n",
    "\n",
    "    markers = MARKERS[cross]\n",
    "    count_markers = pd.cut(VCF[cross].loc[VCF[cross]['vma_uid'].isin(markers)].groupby('vma_uid')['POS'].apply(lambda x: x.iloc[0]), bins=bins).value_counts().rename('marker')\n",
    "    tracts = tracts.copy()\n",
    "    # filter out haplotypes with no recombination breakpoint\n",
    "    for s, df in tracts.groupby('strain'):\n",
    "        if df.shape[0] == 1:\n",
    "            tracts.drop(df.index, inplace=True)\n",
    "    count_bkp = pd.cut(tracts[['start','end']].values.flatten(), bins=bins).value_counts().rename('bkp')\n",
    "    dat = pd.concat([count_markers, count_bkp], axis=1)\n",
    "    dat['mid'] = [i.mid for i in dat.index]\n",
    "    dat['cross'] = cross\n",
    "    dat['bin'] = dat.index\n",
    "    breakpoints.append(dat)\n",
    "\n",
    "breakpoints = pd.concat(breakpoints).reset_index(drop=True)\n",
    "        \n",
    "# compute recombination rate per window per strain\n",
    "for cross, df in breakpoints.groupby('cross'):\n",
    "    n = ma_strains.loc[(ma_strains['filename'].isin(strains_mthap)) & (ma_strains['cross']==cross)].shape[0]\n",
    "    breakpoints.loc[df.index, 'rate'] = np.where(df['bkp']==0, 0, df['bkp']/(df['marker']*n))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6247e58-813c-4921-9ee0-f98fcc09ad59",
   "metadata": {},
   "source": [
    "## Fig 2B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6cfe8af8-d7f3-49f6-92a1-4f233fa47783",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=[10,6])\n",
    "gs = plt.GridSpec(ncols=1, nrows=2, height_ratios=[3,1], hspace=0.15, left=0.09, right=0.89, top=0.97, bottom=0.08)\n",
    "ax = fig.add_subplot(gs[0])\n",
    "wdw = 250\n",
    "xlim = (-500/wdw, (ref_genome_length+500)/wdw)\n",
    "\n",
    "dat = [np.nan]*22\n",
    "\n",
    "for cross, idx in cross_order.items():\n",
    "    \n",
    "    bp = breakpoints.loc[breakpoints['cross']==cross].sort_values(by='mid').set_index('mid')\n",
    "    m = (bp['marker']/wdw).rename(f'{cross}.mark')\n",
    "    if cross != 'BA1':\n",
    "        r = bp['rate'].rename(f'{cross}.rec')\n",
    "    else:\n",
    "        r = pd.Series(np.repeat(0, m.shape[0]), index=m.index, name=f'{cross}.rec')\n",
    "    \n",
    "    dat[2*idx] = m\n",
    "    dat[2*idx+1] = r\n",
    "\n",
    "dat = pd.concat(dat, axis=1).T\n",
    "vmax_mark = np.quantile(dat.iloc[np.arange(0,22,2)].values.flatten(), 0.98)\n",
    "vmax_rec = np.quantile(dat.iloc[np.arange(0,22,2)+1].values.flatten(), 0.98)\n",
    "\n",
    "mask = np.ndarray(dat.shape)\n",
    "mask[np.arange(0,22,2), :] = False\n",
    "mask[np.arange(0,22,2)+1, :] = True\n",
    "hm = np.ma.MaskedArray(dat, mask)\n",
    "\n",
    "HM1 = ax.imshow(hm, aspect='auto', interpolation='nearest', cmap='Reds',\n",
    "                vmin=-0.2*vmax_mark, vmax=vmax_mark)\n",
    "\n",
    "mask = np.ndarray(dat.shape)\n",
    "mask[np.arange(0,22,2), :] = True\n",
    "mask[np.arange(0,22,2)+1, :] = False\n",
    "hm = np.ma.MaskedArray(dat, mask)\n",
    "HM2 = ax.imshow(hm, aspect='auto', interpolation='nearest', cmap='Greys',\n",
    "                vmin=-0.2*vmax_rec, vmax=vmax_rec)\n",
    "\n",
    "ax.set_xlim(xlim)\n",
    "ax.set_xticks(np.arange(0, dat.shape[1], 1e4/wdw))\n",
    "ax.set_xticklabels(range(0,90,10))\n",
    "\n",
    "ax.set_ylim(21.6, -0.6)\n",
    "ax.set_yticks(range(22))\n",
    "ax.set_yticklabels(np.tile(['M','R'], 11), size=9)\n",
    "\n",
    "\n",
    "for i in ['left','right','top']:\n",
    "    ax.spines[i].set_visible(False)\n",
    "for y in np.arange(-0.5, 23, 2):\n",
    "    ax.axhline(y, color='white', lw=5, zorder=1)\n",
    "for cross, y in cross_order.items():\n",
    "    ax.text(-4e3/wdw, 2*y+0.5, cross, va='center', ha='right', size=14)\n",
    "\n",
    "#plot color bars\n",
    "\n",
    "ax_cbar = fig.add_axes([0.89, 0.7, 0.01, 0.2])\n",
    "cb = plt.colorbar(HM1, cax=ax_cbar, orientation='vertical', ticks=np.arange(0, vmax_mark, float(f'{vmax_mark/6:.0e}')), \n",
    "                  label=' M (marker\\ndensity, bp$^{-1}$)')\n",
    "cb.outline.set_visible(False)\n",
    "ax_cbar.set_ylim(0, vmax_mark)\n",
    "\n",
    "ax_cbar = fig.add_axes([0.89, 0.4, 0.01, 0.2])\n",
    "cb = plt.colorbar(HM2, cax=ax_cbar, orientation='vertical', ticks=np.arange(0, vmax_rec, float(f'{vmax_rec/6:.0e}')),\n",
    "                  label='R (rec rate,\\nline$^{-1}$ marker$^{-1}$)')\n",
    "cb.outline.set_visible(False)\n",
    "ax_cbar.set_ylim(0, vmax_rec)\n",
    "\n",
    "\n",
    "# plot GFF entries\n",
    "\n",
    "ax = fig.add_subplot(gs[1])\n",
    "xlim = (-500, ref_genome_length+500)\n",
    "ax.arrow(0, 1, ref_genome_length, 0, color='0.9', width=1, head_length=0, head_width=0, zorder=-1)\n",
    "\n",
    "for i in artificial_genome_feat.loc[~artificial_genome_feat['annot_type'].isin(['gc_cluster','other'])].sort_values(by='annot_plot_order', ascending=False).index:\n",
    "    start, end, color, w, z = artificial_genome_feat.loc[i, [3,4,'annot_color','annot_width','annot_plot_order']]\n",
    "    ax.arrow(start, 1, end-start, 0, color=color, width=w, head_length=0, head_width=0, zorder=z)\n",
    "\n",
    "#create linked labels\n",
    "pap_sub = [a for a in pres_abs_poly if a in artificial_genome_feat['Name'].values]\n",
    "for x, a in zip(np.linspace(-6e3, ref_genome_length+6e3, len(pap_sub)),\n",
    "                pap_sub):\n",
    "\n",
    "    fc = at_color_hm[at_dict[a]]\n",
    "    ec = 'white'\n",
    "    tc = 'white'\n",
    "    if fc == 'white':\n",
    "        tc = 'black'\n",
    "        ec = 'black'\n",
    "    if fc == 'limegreen':\n",
    "        tc = 'black'\n",
    "\n",
    "    t = ax.text(x, 6, pres_abs_poly_alias[a], rotation=90, ha='center', va='top', color=tc, size=8,\n",
    "                 bbox=dict(ec=ec, fc=fc, lw=0.5, boxstyle='square,pad=0.18'), zorder=1)\n",
    "    pos = artificial_genome_feat.loc[artificial_genome_feat['Name']==a].iloc[0,3]\n",
    "    ax.plot([pos, x, x], [1.5, 3, 6], lw=0.5, color='black', zorder=-1, clip_on=False)\n",
    "\n",
    "ax.set_xticks(np.arange(0,83e3,10e3))\n",
    "ax.set_xticklabels(np.arange(0,83,10))\n",
    "ax.set_xlabel('kb')\n",
    "ax.set_ylim(0.5, 6)\n",
    "ax.set_yticks([])\n",
    "ax.set_xlim(xlim)\n",
    "for i in ['left','right','top']:\n",
    "    ax.spines[i].set_visible(False)\n",
    "\n",
    "plt.savefig(f'/home/mathieu/mhenault_landrylab/Publications/mito_ma/resubmission2_GRes/fig/Fig2B.svg', dpi=300)\n",
    "#plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54e6568f-0ae2-4d31-949c-8f31b223a90b",
   "metadata": {},
   "source": [
    "## Fig S4-14"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ac38da7-c954-4f2b-a8a2-4b1e79fad457",
   "metadata": {},
   "outputs": [],
   "source": [
    "xlim = (-500,ref_genome_length+500)\n",
    "\n",
    "for cross, tracts in TRACTS.groupby('cross'):\n",
    "\n",
    "    fig = plt.figure(figsize=[8,9])\n",
    "    gs = plt.GridSpec(nrows=4, ncols=1, height_ratios=[10,1.5,1,1], hspace=0.3,\n",
    "                     top=0.92, bottom=0.07, right=0.96, left=0.12)\n",
    "\n",
    "    # plot haplotype paintings\n",
    "    ax = fig.add_subplot(gs[0])\n",
    "\n",
    "    strain_order = STRAIN_ORDER_MARKERS[cross]\n",
    "    strain_order_plot = dict([(j,i) for (i,j) in enumerate(strain_order)])\n",
    "    markers = MARKERS[cross]\n",
    "    vcf_melt = VCF_MELT[cross]\n",
    "    vcf_melt = vcf_melt.loc[(vcf_melt['vma_uid'].isin(markers)) &\n",
    "                            (vcf_melt['higher']==True) &\n",
    "                            (vcf_melt['parent'].isin(parents_dict[cross]))]\n",
    "\n",
    "    alpha = 0.3\n",
    "    for s, df in tracts.groupby('strain'):\n",
    "        if s in strain_order:\n",
    "            y = strain_order_plot[s]\n",
    "            for i in df.index:\n",
    "                (start, end, parent) = df.loc[i, ['start','end','parent']]\n",
    "                c = parents_color[parent.split('.')[-1]]\n",
    "                if start < end:\n",
    "                    fa = FancyArrow(start, y, end-start, 0, width=0.8, head_length=0, head_width=0, color=c, lw=0, alpha=alpha)\n",
    "                    ax.add_patch(fa)\n",
    "                elif start > end:\n",
    "                    fa1 = FancyArrow(0, y, end, 0, width=0.8, head_length=0, head_width=0, color=c, lw=0, alpha=alpha)\n",
    "                    fa2 = FancyArrow(start, y, ref_genome_length-start, 0, width=0.8, head_length=0, head_width=0, color=c, lw=0, alpha=alpha)\n",
    "                    ax.add_patch(fa1)\n",
    "                    ax.add_patch(fa2)\n",
    "            ax.text(-500, y, ma_strains.loc[s, 'mt_haplotype'], ha='right', va='center', size=6)\n",
    "\n",
    "    for (s, parent), df in vcf_melt.groupby(['filename','parent']):\n",
    "        if s in strain_order:\n",
    "            y = strain_order_plot[s]\n",
    "            c = parents_color[parent.split('.')[-1]]\n",
    "            ax.scatter(df['POS'], np.repeat(y, df.shape[0]), s=6, color=c)\n",
    "\n",
    "    ax.set_ylim(-3, len(strain_order_plot))\n",
    "    ax.set_xlim(xlim)\n",
    "    ax.set_xticks(np.arange(0, 81e3, 1e4))\n",
    "    ax.set_xticklabels(range(0,90,10))\n",
    "    for i in ['left','right','top']:\n",
    "        ax.spines[i].set_visible(False)\n",
    "    ax.set_yticks([])\n",
    "    ax.legend(handles=[Line2D([0], [0], color='white', marker='s', ms=12, mfc=parents_color[parent.split('.')[-1]],\n",
    "                              label=fr'{parent.split(\".\")[-1]} (${parents_group[parent.split(\".\")[-1]]}$)', ) for parent in parents_dict[cross]],\n",
    "              ncol=2, frameon=False, bbox_to_anchor=[0.5,0.99], loc=8)\n",
    "\n",
    "    #set title of the main axes\n",
    "    fig.text(0.5, 0.99, f'{cross} ({len(markers)} markers, {len(strain_order)} haplotypes)', size=14, ha='center', va='top')\n",
    "\n",
    "    \n",
    "    # plot GFF entries\n",
    "    ax = fig.add_subplot(gs[1])\n",
    "    for i in ['left','right','top']:\n",
    "        ax.spines[i].set_visible(False)\n",
    "    ax.arrow(0, 1, ref_genome_length, 0, color='0.9', lw=0, width=1, head_length=0, head_width=0, zorder=-1)\n",
    "\n",
    "    legend_elms = []\n",
    "    for at in annot_type_order:\n",
    "        if at != 'gc_cluster':\n",
    "            l = annot_type_alias[at]\n",
    "            fc = annot_type_color[at]\n",
    "            lw = 0\n",
    "            if fc == 'white':\n",
    "                lw = 1\n",
    "            legend_elms.append(Line2D([0], [0], color='w', marker='s', ms=9, mfc=fc, mec='black', mew=lw, label=l))\n",
    "    ax.legend(handles=legend_elms, ncol=6, loc=9, bbox_to_anchor=(0.5, 1.1), frameon=False,\n",
    "             borderpad=0.0, labelspacing=0.2, handlelength=0.3, columnspacing=1.5)\n",
    "\n",
    "    for i in artificial_genome_feat.loc[~artificial_genome_feat['annot_type'].isin(['gc_cluster','other'])]\\\n",
    ".sort_values(by='annot_plot_order', ascending=False).index:\n",
    "        start, end, color, w, z = artificial_genome_feat.loc[i, [3,4,'annot_color','annot_width','annot_plot_order']]\n",
    "        ax.arrow(start, 1, end-start, 0, color=color, lw=0, width=w, head_length=0, head_width=0, zorder=z)\n",
    "    ax.set_xlim(xlim)\n",
    "    ax.set_ylim(0.45, 4)\n",
    "    ax.set_xticks(np.arange(0, 81e3, 1e4))\n",
    "    ax.set_xticklabels(range(0,90,10))\n",
    "    ax.set_yticks([])\n",
    "\n",
    "    if cross in ['BA1', 'BA2']:\n",
    "        plot_rearrangement_SpA()\n",
    "\n",
    "    # plot recombination rate\n",
    "    bp = breakpoints.loc[breakpoints['cross']==cross].sort_values(by='mid')\n",
    "\n",
    "    ax = fig.add_subplot(gs[2])\n",
    "    ax.plot(bp['mid'], bp['rate'], color='k', zorder=1, clip_on=False)\n",
    "    ax.set_ylabel('rec rate\\n(line$^{-1}$ marker$^{-1}$)', size=8)\n",
    "    ax.set_xlim(xlim)\n",
    "    ax.set_xticks(np.arange(0, 81e3, 1e4))\n",
    "    ax.set_xticklabels(range(0,90,10))\n",
    "    sns.despine(ax=ax, trim=True)\n",
    "\n",
    "    #plot marker density\n",
    "    ax = fig.add_subplot(gs[3])\n",
    "    ax.plot(bp['mid'], bp['marker']*0.01, color='red', zorder=0)\n",
    "    ax.set_ylabel('marker density\\n(bp$^{-1}$)', size=8)\n",
    "    ax.set_xlim(xlim)\n",
    "    ax.set_xticks(np.arange(0, 81e3, 1e4))\n",
    "    ax.set_xticklabels(range(0,90,10))\n",
    "    ax.set_xlabel('kb')\n",
    "    sns.despine(ax=ax, trim=True)\n",
    "\n",
    "    #plt.savefig(f'/home/mathieu/mhenault_landrylab/Publications/mito_ma/resubmission2_GRes/fig/detailed_haplotypes_paintings_{cross}.svg')\n",
    "    #plt.show()\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13c0bef3-48d8-4721-b275-94ba1f809475",
   "metadata": {},
   "source": [
    "## Recombination rate, tract length and feature enrichment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2aaf7c8d-698c-4b9e-b810-44635e56a772",
   "metadata": {},
   "outputs": [],
   "source": [
    "#import growth rates in liquid media from Fijarczyk et al. 2021\n",
    "growth = pd.read_csv('/home/mathieu/mhenault_landrylab/Experiments/generation_time/analysis/max_yield.csv', index_col=0)\n",
    "growth = growth.loc[(growth['sp_high_t0']) & (growth['sp_growth'])].groupby('strain')['max_yield'].mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed04781a-d152-408b-b255-b68139c2d73c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#compute the sum of parental mtDNA sizes\n",
    "parents_genome_size = {cross: sum([len(CORR[p.split('.')[-1]].seq) for p in parents_dict[cross]]) for cross in cross_order}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "69e89dca-83e5-4d38-9c99-519cb33ca345",
   "metadata": {},
   "outputs": [],
   "source": [
    "parents_dist_matrix = pd.read_csv('/mnt/HDD3/mito_ma/divergence/nuc_pairwise_divergence.csv', index_col=0)\n",
    "taxa = pd.read_csv('/mnt/HDD3/mito_ma/divergence/taxa.csv', index_col=3)\n",
    "parents_dist = {}\n",
    "for cross in cross_order:\n",
    "    \n",
    "    nuc_dist = []\n",
    "    Cross = cross[:-1]\n",
    "    g1, g2 = Cross[0], Cross[1:]\n",
    "    P1 = taxa.loc[g1, 'strain_id']\n",
    "    P2 = taxa.loc[g2, 'strain_id']\n",
    "    \n",
    "    for i,j in itertools.product(P1, P2):\n",
    "        if i != j and [i, j] == sorted([i,j]):\n",
    "            nuc_dist.append(parents_dist_matrix.loc[i,j])\n",
    "    \n",
    "    parents_dist[cross] = np.mean(nuc_dist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1dcb1c49-5916-4dac-8a5d-379b6e29aae0",
   "metadata": {},
   "outputs": [],
   "source": [
    "#build recombination summary tables:\n",
    "# count of rec tracts per line\n",
    "REC = []\n",
    "# rec tract lengths\n",
    "RECL = []\n",
    "# features of rec breakpoints\n",
    "RECF = []\n",
    "for (cross, s), df in TRACTS.groupby(['cross','strain']):\n",
    "    if s in strains_mthap:\n",
    "        if df.shape[0] > 1:\n",
    "            bp = df[['start','end']].values.flatten()\n",
    "            REC.append([cross, s, bp.shape[0]/2]) #divide by two, because each event has 2 junctions\n",
    "\n",
    "            for b in bp:\n",
    "                F = gft[b]\n",
    "                if F:\n",
    "                    F = list(F)\n",
    "                    at, name = artificial_genome_feat.loc[[f[2] for f in F]].sort_values(by='annot_plot_order', ascending=False).iloc[0][['annot_type','Name']].values\n",
    "                    RECF.append([cross, s, b, at, name])\n",
    "                else:\n",
    "                    RECF.append([cross, s, b, 'other', 'none'])\n",
    "            for i in df.index:\n",
    "                start, end = df.loc[i, ['start','end']].values\n",
    "                if start < end:\n",
    "                    RECL.append([cross, s, i, end-start+1])\n",
    "                if start > end:\n",
    "                    RECL.append([cross, s, i, end+ref_genome_length-start+1])\n",
    "        else:\n",
    "            REC.append([cross, s, 0])\n",
    "\n",
    "REC = pd.DataFrame(REC, columns=['cross','strain','count'])\n",
    "RECF = pd.DataFrame(RECF, columns=['cross','strain','breakpoint','annot_type','name'])\n",
    "RECL = pd.DataFrame(RECL, columns=['cross','strain','tract','len'])\n",
    "#transform tract lengths in kb\n",
    "RECL['len'] *= 1e-3\n",
    "# add bins to RECL\n",
    "RECL['bin'] = pd.cut(RECL['len'], bins=pd.interval_range(start=0, end=83000, freq=100, closed='left'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce40f650-7dcd-46d0-a327-e65a310e5902",
   "metadata": {},
   "outputs": [],
   "source": [
    "# add variables to the REC table\n",
    "# growth-adjusted recombination rate\n",
    "for s, df in REC.groupby('strain'):\n",
    "    for f in ['passage', 'identity_filter', 'diploid_filter', 'timepoint_filter','mt_haplotype']:\n",
    "        REC.loc[df.index, f] = ma_strains.loc[s, f]\n",
    "\n",
    "    s = s.split('.')[-1].split('_')[0]\n",
    "    if s in growth.index:\n",
    "        REC.loc[df.index, 'growth'] = growth.loc[s]\n",
    "\n",
    "# compute rates and growth-adjusted rates\n",
    "median_growth = np.median(REC.loc[~np.isnan(REC['growth']), 'growth'])\n",
    "\n",
    "for (s, cross), df in REC.groupby(['strain','cross']):\n",
    "    df = df.iloc[0]\n",
    "\n",
    "    rate = df['count']/parents_genome_size[cross]\n",
    "    REC.loc[df.name, 'rate'] = rate*1e5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1a8227fd-86d3-43e9-b40e-2ba8bf5bbb4e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# relative abundance of feature types in rec breakpoints\n",
    "RECF_ABD = RECF.value_counts(['cross','name','annot_type']).rename('abd').reset_index()\n",
    "for cross, df in RECF_ABD.groupby('cross'):\n",
    "    RECF_ABD.loc[df.index, 'abd_rel'] = df['abd']/df['abd'].sum()\n",
    "RECF_ABD['at_order'] = RECF_ABD['annot_type'].replace(annot_type_order)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5c53fd49-f99c-43dc-b6c3-fef9223b3eb7",
   "metadata": {},
   "outputs": [],
   "source": [
    "RECF_ABD_AGG = RECF_ABD.groupby(['cross', 'annot_type', 'at_order'])['abd'].sum().reset_index()\n",
    "for cross, df in RECF_ABD_AGG.groupby('cross'):\n",
    "    RECF_ABD_AGG.loc[df.index, 'abd_rel'] = df['abd']/df['abd'].sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "62a4ca69-3a68-4d05-8f01-3df7a602405c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# feature classification of markers\n",
    "MARKF = []\n",
    "for cross, markers in MARKERS.items():\n",
    "    vcf = VCF[cross].groupby('vma_uid').apply(lambda x: x.iloc[0]['POS'])\n",
    "    for m in markers:\n",
    "        pos = vcf.loc[m]\n",
    "        F = gft[pos]\n",
    "        if F:\n",
    "            F = list(F)\n",
    "            at, name = artificial_genome_feat.loc[[f[2] for f in F]].sort_values(by='annot_plot_order', ascending=False).iloc[0][['annot_type','Name']].values\n",
    "            if at == 'gene':\n",
    "                print(pos, at)\n",
    "                break\n",
    "            MARKF.append([cross, m, at, name])\n",
    "        else:\n",
    "            MARKF.append([cross, m, 'other', 'none'])\n",
    "MARKF = pd.DataFrame(MARKF, columns=['cross','vma_uid','annot_type','name'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dcaf92c9-fe5b-4f17-a681-d654a530a9ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "# relative abundance of feature types in markers\n",
    "MARKF_ABD = MARKF.value_counts(['cross','name','annot_type']).rename('abd').reset_index()\n",
    "for cross, df in MARKF_ABD.groupby('cross'):\n",
    "    MARKF_ABD.loc[df.index, 'abd_rel'] = df['abd']/df['abd'].sum()\n",
    "MARKF_ABD['at_order'] = MARKF_ABD['annot_type'].replace(annot_type_order)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70a5ae17-ce32-4355-9f92-7206f8e8707e",
   "metadata": {},
   "outputs": [],
   "source": [
    "MARKF_ABD_AGG = MARKF_ABD.groupby(['cross', 'annot_type', 'at_order'])['abd'].sum().reset_index()\n",
    "for cross, df in MARKF_ABD_AGG.groupby('cross'):\n",
    "    MARKF_ABD_AGG.loc[df.index, 'abd_rel'] = df['abd']/df['abd'].sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c416deca-c346-4186-bab0-cf408b39b2ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "#average variables for crosses\n",
    "AVERAGE_REC = []\n",
    "\n",
    "for cross, df in REC.groupby('cross'):\n",
    "    \n",
    "    mean_rate = df['rate'].mean()\n",
    "    #mean_adj_rate = df['rate_adj'].mean()\n",
    "    mean_len = RECL.loc[RECL['cross']==cross, 'len'].mean()\n",
    "    n_markers = len(MARKERS[cross])\n",
    "    p1, p2 = [p.split('.')[-1] for p in parents_dict[cross]]\n",
    "    dist = parents_dist[cross]\n",
    "    \n",
    "    AVERAGE_REC.append([cross, mean_rate, mean_len, n_markers, dist])\n",
    "AVERAGE_REC = pd.DataFrame(AVERAGE_REC, columns=['cross','rate','len','n_markers','dist'])\n",
    "AVERAGE_REC.set_index('cross', drop=False, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6d011df-ab3b-43fa-8ada-c393b90d689e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def regression_plot(data, x, y, c, px, py, xplot=None):\n",
    "    reg = stats.linregress(data[x], data[y])\n",
    "    if xplot == None:\n",
    "        X = np.array([data[x].min(), data[x].max()])\n",
    "    else:\n",
    "        X = np.array(xplot)\n",
    "    ax.plot(X, X*reg.slope+reg.intercept, color=c, zorder=0)\n",
    "    ax.text(px, py, f'r={reg.rvalue:.3f}\\np={plot_pval_text(reg.pvalue)}', size=10, transform=ax.transAxes, color=c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1304676d-148c-485d-a5ea-a704196e242f",
   "metadata": {},
   "source": [
    "## Fig 3ABC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f801fcf5-8124-478a-a74a-01de4f38e988",
   "metadata": {},
   "outputs": [],
   "source": [
    "for (pis, pis_alias) in zip([True,False], ['', '.no_is']):\n",
    "\n",
    "    plot_intraspecific = pis\n",
    "\n",
    "    fig = plt.figure(figsize=[10, 4.5])\n",
    "\n",
    "    gs = plt.GridSpec(ncols=5, nrows=2, width_ratios=[1.5,1,4,2,2], wspace=0.7, hspace=0.7,\n",
    "                      left=0.05, right=0.97, bottom=0.15, top=0.85)\n",
    "\n",
    "    ### counts of breakpoints\n",
    "    \n",
    "    ax1 = fig.add_subplot(gs[:, 0])\n",
    "    if pis == True:\n",
    "        ax2 = fig.add_subplot(gs[:, 1])\n",
    "    else:\n",
    "        ax2 = fig.add_subplot(gs[:, :2])\n",
    "\n",
    "    fig.text(0.01, 0.93, 'A', size=24, weight='bold')\n",
    "\n",
    "    bkp_count_color = dict(zip(range(0,9,2), \n",
    "                              [f'{1-(i/10):.2f}' for i in np.logspace(0,1,5)]))\n",
    "\n",
    "    y_labels = pd.Series(dtype=str)\n",
    "    for cross, df in REC.groupby('cross'):\n",
    "        y = (cross_order[cross]-10)*-1\n",
    "        y_labels.loc[y] = cross\n",
    "        df1 = df.value_counts('count').reset_index()\n",
    "        df1.columns = ['bkp','count']\n",
    "        df1['freq'] = df1['count']/df1['count'].sum()\n",
    "        df1 = df1.sort_values(by='bkp')\n",
    "        df1['cumsum'] = np.cumsum(df1['freq'])\n",
    "\n",
    "        for i in df1.index:\n",
    "            ct, cs = df1.loc[i, ['bkp', 'cumsum']]\n",
    "            ax1.barh(y, cs, color=bkp_count_color[ct], lw=0, zorder=(ct/2-4)*-1)\n",
    "\n",
    "        perc_rec = (1-df1.iloc[0,2])*100\n",
    "        ax2.barh(y, perc_rec, color=cross_color[cross], lw=0)\n",
    "\n",
    "    \n",
    "    ax1.set_yticks(range(11))\n",
    "    ax1.set_yticklabels(y_labels.loc[range(11)])\n",
    "    ax1.set_xticks([0,0.5,1])\n",
    "    ax1.set_xlabel('Proportion of\\nmtDNA haplotypes')\n",
    "\n",
    "    ax2.set_yticks(range(11))\n",
    "    ax2.set_yticklabels(y_labels.loc[range(11)])\n",
    "    ax2.set_xticks([0, 25, 50])\n",
    "    ax2.set_xlabel('% recombinant\\nhaplotypes')\n",
    "\n",
    "    legend_elms = [Line2D([0], [0], color='w', marker='s', ms=10, label=l, mfc=c) for l,c in bkp_count_color.items()]\n",
    "    ax1.legend(handles=legend_elms, loc=3, ncol=3, bbox_to_anchor=[-0.15,1], title='Count of rec tracts', frameon=False,\n",
    "              columnspacing=1, borderaxespad=0.2)\n",
    "    \n",
    "    if pis == False:\n",
    "        ax1.remove()\n",
    "        ax2.set_xticks(np.arange(0,61,10))\n",
    "\n",
    "    ### recombination rate\n",
    "\n",
    "    fig.text(0.29, 0.93, 'B', size=24, weight='bold')\n",
    "\n",
    "    ax = fig.add_subplot(gs[0,2])\n",
    "\n",
    "\n",
    "    sns.violinplot(x='cross', y='rate', data=REC, order=cross_order, color='w', ax=ax, zorder=0,\n",
    "                  cut=0, scale='width', inner=None, lw=1)\n",
    "    sns.stripplot(x='cross', y='rate', data=REC, order=cross_order, ax=ax,\n",
    "                  palette=cross_color, size=4, jitter=0.15, alpha=0.3, zorder=3)\n",
    "\n",
    "    ax.set_xticklabels(cross_order, rotation=45, ha='right')\n",
    "    ax.set_xlabel('')\n",
    "    ax.set_ylabel('Rec rate\\n'+r'($\\times10^{-5}$ bp$^{-1}$)')\n",
    "\n",
    "    ax.scatter(np.arange(11), AVERAGE_REC.loc[cross_order, 'rate'], color=(1,1,1,0), edgecolor='k', zorder=4)\n",
    "\n",
    "    ax = fig.add_subplot(gs[0,3])\n",
    "    for cross in cross_order:\n",
    "        mean = AVERAGE_REC.loc[cross, 'rate']\n",
    "        n_markers = AVERAGE_REC.loc[cross, 'n_markers']\n",
    "        ax.scatter(n_markers, mean, color=cross_color[cross])\n",
    "    ax.set_xlabel('Number of markers')\n",
    "    ax.set_ylabel('Average rec rate\\n'+r'($\\times10^{-5}$ bp$^{-1}$)')\n",
    "\n",
    "    # regression\n",
    "    regression_plot(AVERAGE_REC, 'n_markers', 'rate', 'k', 0.1, 0.2)\n",
    "\n",
    "    ax = fig.add_subplot(gs[0,4])\n",
    "    for cross in cross_order:\n",
    "        mean = AVERAGE_REC.loc[cross, 'rate']\n",
    "        dist = AVERAGE_REC.loc[cross, 'dist']\n",
    "        ax.scatter(dist, mean, color=cross_color[cross])\n",
    "    ax.set_xlabel('Parental divergence\\n(subs site$^{-1}$)')\n",
    "    ax.set_ylabel('Average rec rate\\n'+r'($\\times10^{-5}$ bp$^{-1}$)')\n",
    "\n",
    "    # regression\n",
    "    regression_plot(AVERAGE_REC, 'dist', 'rate', 'k', 0.5, 0.8, xplot=None)\n",
    "    if plot_intraspecific:\n",
    "        regression_plot(AVERAGE_REC.loc[AVERAGE_REC['cross'].apply(lambda x: x not in ['BSc1','BSc2'])],\n",
    "                        'dist', 'rate', 'red', 0.45, 0.1, xplot=(0,0.04))\n",
    "\n",
    "    ### recombination tract length\n",
    "\n",
    "    fig.text(0.29, 0.46, 'C', size=24, weight='bold')\n",
    "\n",
    "    ax = fig.add_subplot(gs[1,2])\n",
    "\n",
    "    sns.violinplot(x='cross', y='len', data=RECL, order=cross_order, color='w', ax=ax, zorder=0,\n",
    "                  cut=0, scale='width', inner=None, lw=1)\n",
    "    sns.stripplot(x='cross', y='len', data=RECL, order=cross_order, ax=ax,\n",
    "                  palette=cross_color, size=4, jitter=0.15, alpha=0.3, zorder=3)\n",
    "\n",
    "    ax.set_xticklabels(cross_order, rotation=45, ha='right')\n",
    "    ax.set_xlabel('')\n",
    "    ax.set_ylabel('Rec tract length\\n(kb)')\n",
    "\n",
    "    ax.scatter(np.arange(11), AVERAGE_REC.loc[cross_order, 'len'], color=(1,1,1,0), edgecolor='k', zorder=4)\n",
    "\n",
    "    ax = fig.add_subplot(gs[1,3])\n",
    "    for cross in cross_order:\n",
    "        mean = AVERAGE_REC.loc[cross, 'len']\n",
    "        n_markers = AVERAGE_REC.loc[cross, 'n_markers']\n",
    "        ax.scatter(n_markers, mean, color=cross_color[cross])\n",
    "    ax.set_xlabel('Number of markers')\n",
    "    ax.set_ylabel('Average rec tract\\nlength (kb)')\n",
    "\n",
    "    # regression\n",
    "    regression_plot(AVERAGE_REC.loc[AVERAGE_REC['cross']!='BA1'], 'n_markers', 'len', 'k', 0.2, 0.6)\n",
    "\n",
    "    ax = fig.add_subplot(gs[1,4])\n",
    "    for cross in cross_order:\n",
    "        mean = AVERAGE_REC.loc[cross, 'len']\n",
    "        dist = AVERAGE_REC.loc[cross, 'dist']\n",
    "        ax.scatter(dist, mean, color=cross_color[cross])\n",
    "    ax.set_xlabel('Parental divergence\\n(subs site$^{-1}$)')\n",
    "    ax.set_ylabel('Average rec tract\\nlength (kb)')\n",
    "\n",
    "    # regression\n",
    "    regression_plot(AVERAGE_REC.loc[AVERAGE_REC['cross']!='BA1'], 'dist', 'len', 'k', 0.6, 0.4)\n",
    "    if plot_intraspecific:\n",
    "        regression_plot(AVERAGE_REC.loc[~AVERAGE_REC['cross'].isin(['BA1','BSc1','BSc2'])],\n",
    "                        'dist', 'len', 'red', 0.1, 0.85, xplot=(0,0.04))\n",
    "\n",
    "\n",
    "    ax = fig.add_subplot(gs[0, 2:])\n",
    "    ax.axis('off')\n",
    "    legend_elms = [Line2D([0], [0], color='white', marker='o', ms=8, mfc=cross_color[cross], label=cross) for cross in cross_order]\n",
    "    ax.legend(handles=legend_elms, ncol=6, loc=3, bbox_to_anchor=[0.08, 1.05])\n",
    "\n",
    "    sns.despine()\n",
    "    #if pis == True:\n",
    "        #plt.savefig(f'/home/mathieu/mhenault_landrylab/Publications/mito_ma/resubmission2_GRes/fig/Fig3ABC{pis_alias}.svg', dpi=300)\n",
    "        #plt.show()\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b51c2b5-cbb6-49ac-b8de-98eca01dc095",
   "metadata": {},
   "outputs": [],
   "source": [
    "#compute frequency deviations (i.e. overrepresentation score) \n",
    "# for aggregated and expanded  datasets\n",
    "\n",
    "\n",
    "freq_dev_agg = {}\n",
    "chi2_fdagg_pval = []\n",
    "for cross in cross_order:\n",
    "    \n",
    "    freq_obs = RECF_ABD_AGG.loc[RECF_ABD_AGG['cross']==cross].set_index('annot_type')['abd'].rename('obs')\n",
    "    freq_exp = MARKF_ABD_AGG.loc[MARKF_ABD_AGG['cross']==cross].set_index('annot_type')['abd'].rename('exp')\n",
    "    \n",
    "    freq = pd.concat([freq_obs, freq_exp], axis=1).fillna(0)\n",
    "    chi2 = stats.chisquare(freq['obs'], freq['exp']/freq['exp'].sum()*freq['obs'].sum())\n",
    "    chi2_fdagg_pval.append([cross, chi2[1]])\n",
    "    freq_dev_agg[cross] = (freq['obs']/freq['obs'].sum())-(freq['exp']/freq['exp'].sum())\n",
    "    \n",
    "freq_dev_agg = pd.DataFrame(freq_dev_agg)\n",
    "chi2_fdagg_pval = pd.DataFrame(chi2_fdagg_pval, columns=['cross', 'pval']).set_index('cross')\n",
    "chi2_fdagg_pval.drop('BA1', inplace=True)\n",
    "chi2_fdagg_pval['pval_corr'] = multipletests(chi2_fdagg_pval['pval'], method='fdr_bh')[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca1c3a2f-5e52-4cb0-8079-bc4e64baca5c",
   "metadata": {},
   "outputs": [],
   "source": [
    "freq_dev = pd.concat([RECF_ABD.set_index(['cross','annot_type','name'])['abd_rel'].rename('rec_abd_rel'),\n",
    "                      MARKF_ABD.set_index(['cross','annot_type','name'])['abd_rel'].rename('mark_abd_rel'),\n",
    "                      at_ident.set_index(['cross','annot_type','name'])['identity']], axis=1).fillna(0)\n",
    "freq_dev['freq_dev'] = freq_dev['rec_abd_rel'] - freq_dev['mark_abd_rel']\n",
    "freq_dev = freq_dev.loc[[c for c in cross_order if c!='BA1']]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21f9d7f8-cafe-4ac0-a9cb-a473f33d575d",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Fig 3DEFG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "067b8399-5e72-4679-8624-76e2225e4943",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=[10,5])\n",
    "gs = plt.GridSpec(ncols=3, nrows=2, width_ratios=[2,1,3], wspace=0.45, hspace=0.35,\n",
    "                  left=0.05, right=0.98, bottom=0.1, top=0.85)\n",
    "\n",
    "fig.text(0.01, 0.92, 'D', size=24, weight='bold')\n",
    "\n",
    "for ax_idx, dat, alias in zip([0,1], [MARKF_ABD_AGG, RECF_ABD_AGG], ['Markers','Rec breakpoints']):\n",
    "    \n",
    "    ax = fig.add_subplot(gs[ax_idx, 0])\n",
    "    y_label = pd.Series(dtype=str)\n",
    "    for cross, df in dat.sort_values(by='at_order', ascending=True).groupby('cross'):\n",
    "        df = df.copy()\n",
    "        df['cumsum'] = np.cumsum(df['abd_rel'])\n",
    "        y = (cross_order[cross]-10)*-1\n",
    "        y_label.loc[y] = cross\n",
    "        for i in df.sort_values(by='cumsum', ascending=True).index:\n",
    "            at = df.loc[i, 'annot_type']\n",
    "            fc = annot_type_color[at]\n",
    "            if at == 'intron':\n",
    "                ec = 'k'\n",
    "            else:\n",
    "                ec = fc\n",
    "            z = (annot_type_order[at]-5)*-1\n",
    "            if cross == 'CC1' and alias == 'MARK':\n",
    "                l = annot_type_alias[at]\n",
    "            else:\n",
    "                l = None\n",
    "            ax.barh(y, df.loc[i, 'cumsum'], color=fc, lw=1, edgecolor=ec, zorder=z)\n",
    "    if 3 not in y_label.index:\n",
    "        y_label[3] = 'BA1'\n",
    "    ax.set_title(alias)\n",
    "    ax.set_yticks(range(11))\n",
    "    ax.set_yticklabels(y_label.loc[range(11)])\n",
    "    \n",
    "    if ax_idx == 1:\n",
    "        ax.set_xlabel('Proportion')\n",
    "        \n",
    "# legend squares\n",
    "ax = fig.add_subplot(gs[0,:])\n",
    "ax.axis('off')\n",
    "legend_elms = []\n",
    "for at in annot_type_order:\n",
    "    l = annot_type_alias[at]\n",
    "    fc = annot_type_color[at]\n",
    "    lw = 0\n",
    "    if fc == 'white':\n",
    "        lw = 1\n",
    "    legend_elms.append(Line2D([0], [0], color='w', marker='s', ms=9, mfc=fc, mec='black', mew=lw, label=l))\n",
    "ax.legend(handles=legend_elms, ncol=4, loc=3, bbox_to_anchor=(0, 1.15), frameon=False,\n",
    "         borderpad=0.0, labelspacing=0.2, handlelength=0.3, columnspacing=1.5)\n",
    "\n",
    "    \n",
    "# heatmap of frequency deviations between markers and recombination breakpoints\n",
    "ax = fig.add_axes([0.36, 0.2, 0.15, 0.55])\n",
    "cbar_ax = fig.add_axes([0.36, 0.85, 0.15, 0.03])\n",
    "fig.text(0.31, 0.83, 'E', size=24, weight='bold')\n",
    "\n",
    "sns.heatmap(freq_dev_agg.T.loc[cross_order, annot_type_order], cmap='BrBG', center=0, ax=ax, \n",
    "            cbar_ax=cbar_ax, cbar_kws=dict(orientation='horizontal', ticks=np.arange(-0.2,0.5,0.2), label='Freq difference'))\n",
    "\n",
    "\n",
    "for cross in chi2_fdagg_pval.index:\n",
    "    ax.text(7.2, cross_order[cross]+0.7, plot_pval_symbol(chi2_fdagg_pval.loc[cross, 'pval_corr']),\n",
    "            size=12, ha='left', va='center')\n",
    "ax.set_xlabel('')\n",
    "ax.set_xticks(np.arange(7)+0.5)\n",
    "ax.set_xticklabels([annot_type_alias[at] for at in annot_type_order], rotation=45, ha='right')\n",
    "\n",
    "## F panel - plot identity levels\n",
    "ax = fig.add_subplot(gs[0, 2])\n",
    "fig.text(0.55, 0.92, 'F', size=24, weight='bold')\n",
    "legend_elms = [np.nan]*7\n",
    "\n",
    "for (at, cross), df in at_ident.loc[at_ident['annot_type'].isin(annot_type_order)].groupby(['annot_type','cross']):\n",
    "    x = cross_order[cross]-0.35+annot_type_order[at]*0.1\n",
    "    fc = annot_type_color[at]\n",
    "    lw = 0\n",
    "    if fc == 'white':\n",
    "        lw = 1\n",
    "    \n",
    "    ax.scatter(x, df['identity'].mean(), marker='o', color=fc, edgecolors='k', linewidths=lw)\n",
    "    if cross == 'CC1':\n",
    "        legend_elms[annot_type_order[at]] = Line2D([0], [0], color='w', marker='o', mfc=fc, mec='k', mew=lw, label=annot_type_alias[at])\n",
    "    \n",
    "ax.legend(handles=legend_elms, ncol=4, loc=3, bbox_to_anchor=(-0.08, 1.15), frameon=False,\n",
    "         borderpad=0.0, labelspacing=0.2, handlelength=0.3, columnspacing=1.5)\n",
    "\n",
    "ax.set_xlim(-0.6, 10.6)\n",
    "ax.set_xticks(range(11))\n",
    "ax.set_xticklabels(cross_order, rotation=45, ha='right')\n",
    "\n",
    "ax.set_ylim(0.19, 1.03)\n",
    "ax.set_yticks(np.arange(0.2, 1.1, 0.2))\n",
    "ax.set_yticklabels(np.arange(20, 101, 20))\n",
    "ax.set_ylabel('% nt identity')\n",
    "\n",
    "## G panel - identity vs freq deviation\n",
    "ax = fig.add_subplot(gs[1, 2])\n",
    "fig.text(0.55, 0.42, 'G', size=24, weight='bold')\n",
    "\n",
    "for (at, cross), df in at_ident.groupby(['annot_type', 'cross']):\n",
    "    if at in annot_type_order:\n",
    "        fd = freq_dev_agg.loc[at, cross]\n",
    "        fc = annot_type_color[at]\n",
    "        lw = 0\n",
    "        if fc == 'white':\n",
    "            lw = 1\n",
    "        ax.scatter(df['identity'].mean(), fd, c=fc, edgecolor='black', lw=lw, zorder=(annot_type_order[at]*-1)+6)\n",
    "        \n",
    "ax.set_xlim(0.29, 1.03)\n",
    "ax.set_xticks(np.arange(0.3, 1.1, 0.1))\n",
    "ax.set_xticklabels(np.arange(30,101,10))\n",
    "\n",
    "ax.set_xlabel('% nt identity')\n",
    "ax.set_ylabel('Freq difference')\n",
    "\n",
    "sns.despine()\n",
    "for i in ['bottom', 'left']:\n",
    "    cbar_ax.spines[i].set_visible(False)\n",
    "\n",
    "#plt.savefig(f'/home/mathieu/mhenault_landrylab/Publications/mito_ma/resubmission2_GRes/fig/Fig3DEFG.svg', dpi=300)\n",
    "#plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd767b5e-385f-4ed2-bf17-5194988a821b",
   "metadata": {},
   "source": [
    "## Fig S17"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f25e8eab-8de1-4f12-9afd-9e2691df4c35",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=[8,8])\n",
    "gs = plt.GridSpec(ncols=4, nrows=4, hspace=0.5, wspace=0.6, left=0.1, top=0.95, right=0.98, bottom=0.08)\n",
    "cross_ax = dict(zip(['CC1','CC2','CC3','BB1','BB2','BC1','BC2','BA2','BSc1','BSc2'], itertools.product(range(3), range(4))))\n",
    "\n",
    "fig.text(0.01, 0.96, 'A', weight='bold', size=24)\n",
    "\n",
    "legend_elms = [np.nan]*7\n",
    "for cross, df in freq_dev.groupby('cross'):\n",
    "    ax = fig.add_subplot(gs[cross_ax[cross]])\n",
    "    for at, df1 in df.groupby('annot_type'):\n",
    "        if at in annot_type_order:\n",
    "            \n",
    "            fc = annot_type_color[at]\n",
    "            lw = 0\n",
    "            if fc == 'white':\n",
    "                lw = 1\n",
    "            ax.scatter(df1['identity'], df1['freq_dev'], c=fc, edgecolor='black', lw=lw, alpha=0.5, zorder=(annot_type_order[at]*-1)+6)\n",
    "            \n",
    "            if cross == 'CC1':\n",
    "                legend_elms[annot_type_order[at]] = Line2D([0], [0], color='w', marker='o', mfc=fc, mec='k', mew=lw, label=annot_type_alias[at])\n",
    "        \n",
    "    ax.text(0.5, 1, cross, ha='center', va='top', transform=ax.transAxes, size=14)\n",
    "    ax.set_xlim(-0.05, 1.05)\n",
    "    ax.set_xticks(np.arange(0, 1.1, 0.25))\n",
    "    ax.set_xticklabels(np.arange(0,101,25))\n",
    "    ax.set_xlabel('% nt identity')\n",
    "    ax.set_ylim(-0.3, 0.3)\n",
    "    ax.set_ylabel('freq difference', labelpad=1)\n",
    "    \n",
    "ax = fig.add_subplot(gs[2, 2:])\n",
    "ax.axis('off')\n",
    "ax.legend(handles=legend_elms, loc=10, ncol=3, handlelength=0.3)\n",
    "   \n",
    "fig.text(0.01, 0.25, 'B', weight='bold', size=24)\n",
    "ax = fig.add_subplot(gs[3, :2])\n",
    "dat = freq_dev.reset_index()\n",
    "dat = dat.loc[dat['annot_type']=='exon']\n",
    "name_order = np.sort(dat['name'].unique())\n",
    "sns.stripplot(x='name', y='freq_dev', hue='cross', order=name_order, palette=cross_color, \n",
    "              hue_order=['CC1','CC2','CC3','BB1','BB2','BC1','BC2','BA2','BSc1','BSc2'], data=dat, ax=ax)\n",
    "ax.legend_.remove()\n",
    "ax.set_xticklabels(name_order, rotation=45, ha='right')\n",
    "ax.set_xlabel('')\n",
    "ax.set_ylim(-0.1, 0.5)\n",
    "ax.set_ylabel('freq difference')\n",
    "\n",
    "\n",
    "ax = fig.add_subplot(gs[3, 2:])\n",
    "ax.axis('off')\n",
    "legend_elms = [Line2D([0], [0], color='w', marker='o', mfc=cross_color[cross], label=cross)\n",
    "               for cross in ['CC1','CC2','CC3','BB1','BB2','BC1','BC2','BA2','BSc1','BSc2']]\n",
    "ax.legend(handles=legend_elms, loc=10, ncol=3, handlelength=0.3)\n",
    "    \n",
    "sns.despine()\n",
    "#plt.savefig('/home/mathieu/mhenault_landrylab/Publications/mito_ma/resubmission2_GRes/fig/freq_diff_ident.svg')\n",
    "#plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdcc7705-8a4e-4782-9934-4e2fb8aec6fc",
   "metadata": {},
   "source": [
    "## Inheritance biases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65c08003-7314-4d81-afa0-e75132ec334d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "INHERIT = []\n",
    "for (cross,s), df in TRACTS.loc[TRACTS['strain'].isin(strains_mthap)].groupby(['cross','strain']):\n",
    "    p1, p2 = parents_dict[cross]\n",
    "    \n",
    "    tracts_data = pd.Series(np.repeat(np.nan, ref_genome_length), index=np.arange(ref_genome_length)+1)\n",
    "    for i in df.index:\n",
    "        start, end, p = df.loc[i, ['start','end', 'parent']]\n",
    "        if start < end:\n",
    "            tracts_data.loc[start:end] = p\n",
    "        if start > end:\n",
    "            tracts_data.loc[start:] = p\n",
    "            tracts_data.loc[:end] = p\n",
    "    \n",
    "    #score inheritance of specific features\n",
    "    for (at, f, start, end), df1 in artificial_genome_feat.groupby(['annot_type', 'Name',3,4]):\n",
    "        inherit = tracts_data.loc[start:end].value_counts()\n",
    "        length = end-start+1\n",
    "        if p1 in inherit.index:\n",
    "            cp1 = inherit.loc[p1]\n",
    "        else:\n",
    "            cp1 = 0\n",
    "        \n",
    "        if p2 in inherit.index:\n",
    "            cp2 = inherit.loc[p2]\n",
    "        else:\n",
    "            cp2 = 0\n",
    "        \n",
    "        cp_sum = cp1+cp2\n",
    "        if cp_sum > 0 and cp_sum/length >= 0.8:\n",
    "            ratio = cp1/cp_sum\n",
    "        else:\n",
    "            ratio = np.nan\n",
    "        \n",
    "        INHERIT.append([cross, s, at, f, p1, p2, cp1, cp2, length, ratio])\n",
    "        \n",
    "    # score global inheritance\n",
    "    inherit = tracts_data.value_counts()\n",
    "        \n",
    "    if p1 in inherit.index:\n",
    "        cp1 = inherit.loc[p1]\n",
    "    else:\n",
    "        cp1 = 0\n",
    "\n",
    "    if p2 in inherit.index:\n",
    "        cp2 = inherit.loc[p2]\n",
    "    else:\n",
    "        cp2 = 0\n",
    "\n",
    "    cp_sum = cp1+cp2    \n",
    "    ratio = cp1/cp_sum\n",
    "    \n",
    "    INHERIT.append([cross, s, 'whole_genome', 'whole_genome', p1, p2, cp1, cp2, ref_genome_length, ratio])\n",
    "\n",
    "INHERIT = pd.DataFrame(INHERIT, columns=['cross','strain','annot_type','Name','p1','p2','cp1','cp2','len','ratio'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "007e4b42-9424-473d-b670-95ef77a66e41",
   "metadata": {},
   "outputs": [],
   "source": [
    "#produce discrete counts\n",
    "def generate_discrete_call(x, threshold=0.1):\n",
    "    \n",
    "    p1, p2, ratio = x[['p1','p2','ratio']]\n",
    "    if np.isnan(ratio):\n",
    "        call = 'none'\n",
    "    else:\n",
    "        if ratio >= 1-threshold:\n",
    "            call = p1\n",
    "        elif ratio <= threshold:\n",
    "            call = p2\n",
    "        else:\n",
    "            call = 'rec'\n",
    "\n",
    "    return call"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b74bc6f-0e18-490c-a351-c3b8d27f76f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "INHERIT['call'] = INHERIT.apply(lambda x: generate_discrete_call(x), axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fb8d73ed-4915-4e31-8812-6289aa9fe4e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# compute mean inheritance across all mtDNA\n",
    "INH_WHOLE_GENOME = INHERIT.loc[INHERIT['annot_type']=='whole_genome'].groupby('cross')['ratio'].mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74a41dd5-d498-465b-bf82-8ce1ad19eb03",
   "metadata": {},
   "outputs": [],
   "source": [
    "#import mito CNs \n",
    "mito_cn = []\n",
    "for cross, P in parents_dict.items():\n",
    "    p1, p2 = [p.split('.')[-1] for p in P]\n",
    "    cn = {}\n",
    "    for p in (p1, p2): \n",
    "        with open(f'/mnt/HDD3/mito_nanopore/mito_cn/mito_cn_{p}.txt') as handle:\n",
    "            cn[p] = [p] + [float(i) for i in handle.read().split(',')]\n",
    "    \n",
    "    ratio = cn[p1][2]/(cn[p1][2]+cn[p2][2])\n",
    "    mito_cn.append([cross, ratio] + cn[p1] + cn[p2])\n",
    "\n",
    "mito_cn = pd.DataFrame(mito_cn, columns=['cross','ratio','p1','mt_p1','nuc_p1','cn_p1','p2','mt_p2','nuc_p2','cn_p2']).set_index('cross', drop=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1172d7fa-7155-4ffa-b457-d71ae6f26013",
   "metadata": {},
   "source": [
    "## Fig S20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59cf02a7-9e91-474c-afe8-7bea9c53bb45",
   "metadata": {},
   "outputs": [],
   "source": [
    "X = mito_cn.loc[cross_order, 'ratio']\n",
    "Y = INH_WHOLE_GENOME.loc[cross_order]\n",
    "lr = stats.linregress(X, Y)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(5,4))\n",
    "ax.scatter(X, Y, color=[cross_color[cross] for cross in cross_order])\n",
    "\n",
    "X = np.array([X.min(), X.max()])\n",
    "ax.plot(X, X*lr.slope+lr.intercept, color='black', zorder=-1)\n",
    "ax.text(0.3, 0.3, f'r={lr.rvalue:.3f}\\np={lr.pvalue:.3f}', transform=ax.transAxes)\n",
    "ax.set_xlabel('mt CN ratio')\n",
    "ax.set_ylabel('mt inheritance ratio')\n",
    "\n",
    "legend_elms = [Line2D([0], [0], color='white', marker='o', ms=8, mfc=cross_color[cross], label=cross) for cross in cross_order]\n",
    "ax.legend(handles=legend_elms, ncol=1, loc=3, bbox_to_anchor=[1.02,0.12])\n",
    "\n",
    "sns.despine()\n",
    "plt.tight_layout()\n",
    "\n",
    "#plt.savefig(f'/home/mathieu/mhenault_landrylab/Publications/mito_ma/resubmission2_GRes/fig/FigS4_mito_cn.svg')\n",
    "#plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfeb48fb-9041-471a-ab46-349f8312adfd",
   "metadata": {},
   "source": [
    "## Binomial tests for deviation from mtDNA-wide inheritance ratios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0a24984-a62e-498f-b912-4d09054ec4ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "INH_BIN = []\n",
    "for (cross, f, p1, p2), df in INHERIT.loc[(INHERIT['annot_type'].isin(['gene','rna'])) & \n",
    "                                          (~INHERIT['call'].isin(['rec','none']))].groupby(['cross','Name','p1','p2']):\n",
    "    ref_ratio = INH_WHOLE_GENOME.loc[cross]\n",
    "    inherit = df.value_counts('call')\n",
    "    if p1 in inherit.index:\n",
    "        cp1 = inherit.loc[p1]\n",
    "    else:\n",
    "        cp1 = 0\n",
    "    if p2 in inherit.index:\n",
    "        cp2 = inherit.loc[p2]\n",
    "    else:\n",
    "        cp2 = 0\n",
    "    bin_pval = stats.binom_test(cp1, cp1+cp2, ref_ratio)\n",
    "    INH_BIN.append([cross, f, ref_ratio, cp1/(cp1+cp2), bin_pval])\n",
    "INH_BIN = pd.DataFrame(INH_BIN, columns=['cross','feature','ref_ratio','ratio','pval'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e62859f-d769-4835-8fb8-914187506b47",
   "metadata": {},
   "outputs": [],
   "source": [
    "INH_BIN['ratio_corr'] = INH_BIN['ratio']-INH_BIN['ref_ratio']\n",
    "INH_BIN['pval_corr'] = multipletests(INH_BIN['pval'], method='fdr_bh')[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3fdef5c4-31d0-4ad5-a8e7-4a5972a398d0",
   "metadata": {},
   "source": [
    "## Fig S21"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cfeda0cd-515e-4364-ae7a-abb4873f48c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=[9,6])\n",
    "gs = plt.GridSpec(ncols=5, nrows=2, hspace=0.5, wspace=0.4,\n",
    "                 left=0.08, bottom=0.13, top=0.95, right=0.97)\n",
    "\n",
    "feat_order = dict(zip(artificial_genome_feat.sort_values(by=3).loc[artificial_genome_feat['annot_type'].isin(['gene','rna']), 'Name'].values,\n",
    "                     range(11)))\n",
    "cross_ax = dict(zip(['CC1','CC2','CC3','BB1','BB2','BC1','BC2','BA2','BSc1','BSc2'], itertools.product(range(2), range(5))))\n",
    "\n",
    "for cross, df in INH_BIN.groupby('cross'):\n",
    "\n",
    "    if cross != 'BA1':\n",
    "        x,y = cross_ax[cross]\n",
    "        #plot corrected ratios\n",
    "\n",
    "        ref_ratio = INH_WHOLE_GENOME[cross]\n",
    "        bound = np.array([-0.5, 0.5]) + ref_ratio\n",
    "        bound_ticks_labels = np.array([bound[0], ref_ratio, bound[1]])\n",
    "        if bound_ticks_labels[0] < 0:\n",
    "            bound_ticks_labels[0] = 0\n",
    "        if bound_ticks_labels[2] > 1:\n",
    "            bound_ticks_labels[2] = 1\n",
    "        bound_ticks = bound_ticks_labels - ref_ratio\n",
    "\n",
    "        ax = fig.add_subplot(gs[x,y])\n",
    "        sns.barplot(x='feature', y='ratio_corr', order=feat_order, color=cross_color[cross], data=df,\n",
    "                    ax=ax, zorder=1, linewidth=0)\n",
    "\n",
    "        ax.set_facecolor((0,0,0,0))\n",
    "        ax.set_xticklabels([pres_abs_poly_alias[x] for x in feat_order], size=8, rotation=90)\n",
    "        ax.set_xlabel('')\n",
    "\n",
    "        ax.set_ylim(-0.5, 0.5)\n",
    "        ax.set_yticks(bound_ticks)\n",
    "        ax.set_yticklabels([f'{y:.2f}' for y in bound_ticks_labels])\n",
    "        if y == 0:\n",
    "            ax.set_ylabel('Inheritance ratio')\n",
    "        else:\n",
    "            ax.set_ylabel('')\n",
    "\n",
    "        ax.set_title(cross, size=14)\n",
    "\n",
    "        # add p-values\n",
    "        for i in df.index:\n",
    "            feat, ratio, pval = df.loc[i, ['feature','ratio_corr','pval_corr']]\n",
    "            if ratio < 0:\n",
    "                y = ratio-0.05\n",
    "            elif ratio > 0:\n",
    "                y = ratio+0.05\n",
    "            ax.text(feat_order[feat], y-0.02, plot_pval_symbol(pval), ha='center', va='center', size=12, color='k', zorder=2)\n",
    "        \n",
    "        #add background patches\n",
    "        p1, p2 = parents_dict[cross]\n",
    "        for p, sign, va1, va2 in zip([p1, p2], [1, -1], ['bottom','top'], ['top', 'bottom']):\n",
    "            p = p.split('.')[-1]\n",
    "            fa = Rectangle((-0.5, 0), 11, 0.5*sign, fc=parents_color[p], ec='white', alpha=0.15, zorder=0)\n",
    "            ax.add_patch(fa)\n",
    "            ax.text(0.5, 0.5+(sign*0.48), p, va=va2, ha='center', size=10, color='k', transform=ax.transAxes)\n",
    "\n",
    "sns.despine()\n",
    "\n",
    "#plt.savefig('/home/mathieu/mhenault_landrylab/Publications/mito_ma/resubmission2_GRes/fig/inheritance_ratios.svg')\n",
    "#plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17926ca8-b74e-4026-862c-5b505b439cec",
   "metadata": {},
   "source": [
    "# Growth data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3cef8cd7-57cc-4cc9-abf3-46c77fcd4f97",
   "metadata": {},
   "outputs": [],
   "source": [
    "#define dictionaries for conditions\n",
    "cond_order = ['YPD_25','YPD_37','YPEG_25','YPEG_37']\n",
    "cond_color = dict(zip(cond_order, ['1.0', '0.8', '0.6', '0.4']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "432eff4c-6e93-4df5-bc6e-e8b9e8db1566",
   "metadata": {},
   "outputs": [],
   "source": [
    "#import growth data from gitter\n",
    "gitter = pd.read_csv('/home/mathieu/mhenault_landrylab/Experiments/screen_glycerol/results/gitter_mean.tsv', sep='\\t', index_col=0)\n",
    "\n",
    "gitter['strain_passage'] = gitter.apply(lambda x: f'{x[\"strain\"]}_P{x[\"passage\"]:.0f}', axis=1)\n",
    "\n",
    "gitter_pivot = gitter.loc[gitter['contamination_filter']].pivot_table(index='strain_passage', columns='condition', values='auc', aggfunc=lambda x: x)\n",
    "# exclude strain with no growth\n",
    "gitter_pivot.loc[gitter_pivot['YPD_25']<10] = np.nan\n",
    "# nan-out strains which had no cells printed\n",
    "for sp in ['J41_P35','J9_P35','K40_P35','L32_P35','I41_P35','A15_P35','D74_P35','B89_P35','F80_P35','F16_P35','F24_P35']:\n",
    "    gitter_pivot.loc[sp] = np.nan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ff93f9f-b3fb-476d-bd81-6714b976ecc6",
   "metadata": {},
   "outputs": [],
   "source": [
    "#integrate growth data with deletion and score respiration\n",
    "GDR = gitter_pivot.copy()\n",
    "\n",
    "for sp in GDR.index:\n",
    "    if sp in ma_strains.index:\n",
    "        df = ma_strains.loc[sp]\n",
    "        if df.shape[0] == 1:\n",
    "            if df.loc['mt_hap_del'].isna():\n",
    "                print(sp)\n",
    "    s, p = sp.split('_')\n",
    "    GDR.loc[sp, 'strain'] = s\n",
    "    GDR.loc[sp, 'passage'] = p\n",
    "\n",
    "for (sp, cross, mthd), df in ma_strains.loc[~ma_strains['mt_hap_del'].isna()].groupby(['strain_passage','cross','mt_hap_del']):\n",
    "    if sp in GDR.index:\n",
    "        if df.shape[0] == 1:\n",
    "            GDR.loc[sp, 'cross'] = cross\n",
    "            GDR.loc[sp, 'mt_hap_del'] = mthd\n",
    "        else:\n",
    "            GDR.loc[sp, 'cross'] = cross\n",
    "            GDR.loc[sp, 'mt_hap_del'] = sp\n",
    "for sp, df in ma_strains.groupby('strain_passage'):\n",
    "    if sp in GDR.index:\n",
    "        idf = set(df['identity_filter'])\n",
    "        if False in idf:\n",
    "            GDR.loc[sp, 'identity_filter'] = False\n",
    "        else:\n",
    "            GDR.loc[sp, 'identity_filter'] = True\n",
    "# add cross info for all lines, regardless of sequencing data\n",
    "GDR['Cross'] = gitter.groupby('strain_passage').apply(lambda x: x['cross'].iloc[0]).loc[GDR.index]\n",
    "#thermotolerance\n",
    "gd_tests = {'therm_ypd':['YPD_37','YPD_25'],\n",
    "           'therm_ypeg':['YPEG_37','YPEG_25'],\n",
    "           'resp_25':['YPEG_25','YPD_25'],\n",
    "           'resp_37':['YPEG_37','YPD_37']}\n",
    "gd_tests_alias = {'therm_ypd':'thermotolerance YPD',\n",
    "                  'therm_ypeg':'thermotolerance YPEG',\n",
    "                  'resp_25':'respiration 25°C',\n",
    "                  'resp_37':'respiration 37°C'}\n",
    "for t, (c1, c2) in gd_tests.items():\n",
    "    GDR[t] = GDR[c1]/GDR[c2]\n",
    "GDR['YPEG'] = GDR[['YPEG_25','YPEG_37']].mean(axis=1)\n",
    "\n",
    "GDR['resp'] = GDR['YPEG'] > 25\n",
    "GDR.loc[GDR['YPEG'].isna(), 'resp'] = np.nan\n",
    "\n",
    "#manually correct respiration data\n",
    "resp_manual_correction = ['D83_P1', 'D87_P35', 'D93_P35', 'D4_P35', 'A8_P35',\n",
    "                          'J32_P35', 'K30_P35', 'L41_P35', 'J8_P35', 'J49_P35', 'L47_P35']\n",
    "for sp in resp_manual_correction:\n",
    "    GDR.loc[sp, 'resp'] = True"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fafdaad-9bfb-4c15-8eeb-a0c11a54a69b",
   "metadata": {},
   "source": [
    "# mtDNA deletions\n",
    "## Input depth of coverage files on mtDNA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21f6fc5a-3482-438d-806e-d3a541045702",
   "metadata": {},
   "outputs": [],
   "source": [
    "DEPTH = {}\n",
    "idx = 0\n",
    "with ProgressBar(max_value=ma_strains.shape[0]) as bar:\n",
    "    for s in ma_strains.index:\n",
    "        depth = pd.read_csv(f'/mnt/HDD3/mito_ma/depth/{s}.mt.rmdup.rg.depth', sep='\\t', header=None)\n",
    "\n",
    "        depth.columns = ['chrom','pos','depth']\n",
    "        DEPTH[s] = depth\n",
    "        idx += 1\n",
    "        bar.update(idx)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba7fb661-d2d6-4123-938f-34f65b746bd8",
   "metadata": {},
   "source": [
    "## Bin depth in 100 bp windows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c637c26-5f24-436b-a569-aa2002b3bd01",
   "metadata": {},
   "outputs": [],
   "source": [
    "DEPTH_BIN = {}\n",
    "idx = 0\n",
    "with ProgressBar(max_value=len(DEPTH)) as bar:\n",
    "    for s, depth in DEPTH.items():\n",
    "        if s in depth_nuclear.index:\n",
    "            depth['bin'] = pd.cut(depth['pos'], bins=pd.interval_range(start=0, end=82500, freq=100))\n",
    "            depth['Bin'] = depth['bin'].apply(lambda x: x.mid)\n",
    "            depth = depth.groupby('Bin')['depth'].median().rename('depth_median').reset_index()\n",
    "            depth['depth_median_norm'] = depth['depth_median']/depth_nuclear.loc[s, 'median']\n",
    "            depth['strain'] = s\n",
    "            DEPTH_BIN[s] = depth\n",
    "        idx += 1\n",
    "        bar.update(idx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97565f30-48f4-48a7-a134-df9a27f70ed9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# add functional annotations to midpoints of bins used to score coverage depth\n",
    "bin_func_annot = {}\n",
    "for b in set(DEPTH_BIN['HI.4802.001.N701---N502.C68_P1']['Bin']):\n",
    "    F = list(gft[b])\n",
    "    if len(F) > 0:\n",
    "        F = artificial_genome_feat.loc[[f[2] for f in F]]\n",
    "        at = F.sort_values(by=['annot_plot_order'], ascending=False).iloc[0,16]\n",
    "        bin_func_annot[b] = at\n",
    "    else:\n",
    "        bin_func_annot[b] = 'other'\n",
    "bin_func_annot = pd.Series(bin_func_annot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bde4f388-a4af-4d8e-9b38-9d39ff0a48d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# add functional annotations to individual positions\n",
    "pos_func_annot = {}\n",
    "for p in range(1, len(artificial_genome.seq)+1):\n",
    "    F = list(gft[p])\n",
    "    if len(F) > 0:\n",
    "        F = artificial_genome_feat.loc[[f[2] for f in F]]\n",
    "        idx = F.sort_values(by=['annot_plot_order'], ascending=False).index[0]\n",
    "        pos_func_annot[p] = idx\n",
    "    else:\n",
    "        pos_func_annot[p] = -1\n",
    "pos_func_annot = pd.Series(pos_func_annot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "145ea1f7-ccea-48d8-b283-f86e4e43b8c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "for s, db in DEPTH_BIN.items():\n",
    "    db['func'] = bin_func_annot.loc[db['Bin']].values\n",
    "    DEPTH_BIN[s] = db"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88919d9c-f82d-44f7-9929-030312f70555",
   "metadata": {},
   "source": [
    "## Compute coverage statistics to identify deleted haplotypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2c2f7e2-42f2-4367-af51-ff78bf71d917",
   "metadata": {},
   "outputs": [],
   "source": [
    "DBF = []\n",
    "for s, db in DEPTH_BIN.items():\n",
    "    if ma_strains.loc[s, 'mtdel_filter']:\n",
    "        # define 3 floor threshold for relative depth of coverage (0.1 is retained)\n",
    "        for t in 0.01, 0.05, 0.1:\n",
    "            p = db.groupby('func').apply(lambda x: np.mean(x['depth_median_norm']>t))\n",
    "            DBF.append(pd.concat([pd.Series([s,t], index=['filename','threshold']), p]))\n",
    "\n",
    "DBF = pd.concat(DBF, axis=1).T\n",
    "\n",
    "for c in ['cross','strain','passage','strain_passage']:\n",
    "    DBF[c] = ma_strains.loc[DBF['filename'], c].values\n",
    "\n",
    "ft_list = ['exon','intron','orf','other','rna_exon','tRNA']\n",
    "for (cross,t), df in DBF.groupby(['cross','threshold']):\n",
    "    for ft in ft_list:\n",
    "        DBF.loc[df.index, ft] = (df[ft]-df[ft].mean())/df[ft].std()\n",
    "\n",
    "DBF['ft_sum'] = DBF[ft_list].sum(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d6d34d6-a3ac-4ca2-9ead-77bf3cb0d023",
   "metadata": {},
   "outputs": [],
   "source": [
    "# manualy define thresholds corresponding to deleted haplotypes\n",
    "ft_thres = {'CC1':-11,\n",
    "           'CC2':-9,\n",
    "           'CC3':-10,\n",
    "           'BB1':-10,\n",
    "           'BB2':-5,\n",
    "           'BC1':-4.5,\n",
    "           'BC2':-4,\n",
    "           'BA1':-5,\n",
    "           'BA2':0,\n",
    "           'BSc1':1,\n",
    "           'BSc2':0.5}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef04ad74-1b69-4e1e-b857-a91ca21f34e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "for cross, df in DBF.loc[DBF['threshold']==0.1].groupby('cross'):\n",
    "    t = ft_thres[cross]\n",
    "    DBF.loc[df.index, 'complete'] = df['ft_sum'] > t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c81de1d-3997-4840-98d6-ffdb79f6be7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "#manually correct some complete profiles\n",
    "DBF.loc[(DBF['filename']=='HI.4802.002.N703---N504.B7_P1') & (DBF['threshold']==0.1), 'complete'] = True\n",
    "DBF.loc[(DBF['filename']=='NS.1249.002.N703---N503.E19_P1') & (DBF['threshold']==0.1), 'complete'] = True"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4de940bf-3ccb-48bf-9390-392769c658ac",
   "metadata": {},
   "source": [
    "## Fig 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a0bd5da-7816-4775-a3c6-140520b4a414",
   "metadata": {},
   "outputs": [],
   "source": [
    "for (pis, pis_alias) in zip([True,False], ['', '.no_is']):\n",
    "\n",
    "    plot_intraspecific = pis\n",
    "\n",
    "    fig = plt.figure(figsize=[9,9])\n",
    "    gs = plt.GridSpec(ncols=3, nrows=3, width_ratios=[4,4,5], wspace=0.65, hspace=0.45,\n",
    "                      left=0.08, right=0.97, top=0.95, bottom=0.06)\n",
    "\n",
    "    ### Respiration loss ###\n",
    "\n",
    "    ax = fig.add_subplot(gs[0,0])\n",
    "\n",
    "    df = GDR.loc[GDR['identity_filter']!=False].value_counts(['Cross','resp']).rename('count').reset_index()\\\n",
    "    .pivot_table(index='Cross', columns='resp', values='count', aggfunc=lambda x: x)\n",
    "    df['ratio'] = df[False]/(df[True] + df[False])*100\n",
    "    ax.barh(range(11), df.loc[cross_order, 'ratio'], color=[cross_color[cross] for cross in cross_order])\n",
    "    for (cross,y) in cross_order.items():\n",
    "        x = df.loc[cross, 'ratio']\n",
    "        total = df.loc[cross, True] + df.loc[cross, False]\n",
    "        ax.text(x+1, y, f'{x:.1f}% ({total:.0f})', size=9, ha='left', va='center')\n",
    "    ax.set_yticks(range(11))\n",
    "    ax.set_yticklabels(cross_order)\n",
    "    ax.invert_yaxis()\n",
    "    ax.set_xlim(0,49)\n",
    "    ax.set_xlabel('% respiration loss')\n",
    "\n",
    "    ### mtDNA deletion ###\n",
    "\n",
    "    ax = fig.add_subplot(gs[0,1])\n",
    "\n",
    "    df = DBF.loc[DBF['threshold']==0.1].copy()\n",
    "    S = list(set(df['filename']))\n",
    "\n",
    "    df1 = df.value_counts(['cross','complete']).rename('count').reset_index().pivot_table(index='cross', columns='complete', values='count', aggfunc=lambda x: x).fillna(0)\n",
    "    df1['ratio'] = df1[False]/(df1[True] + df1[False])*100\n",
    "\n",
    "    ax.barh(range(11), df1.loc[cross_order, 'ratio'], color=[cross_color[cross] for cross in cross_order])\n",
    "    for (cross,y) in cross_order.items():\n",
    "        x = df1.loc[cross, 'ratio']\n",
    "        total = df1.loc[cross, True] + df1.loc[cross, False]\n",
    "        ax.text(x+1, y, f'{x:.1f}% ({total:.0f})', size=9, ha='left', va='center')\n",
    "    ax.set_yticks(range(11))\n",
    "    ax.set_yticklabels(cross_order)\n",
    "    ax.invert_yaxis()\n",
    "    ax.set_xlim(0,49)\n",
    "    ax.set_xlabel('% deleted mtDNAs')\n",
    "\n",
    "    ### Correlation of deletion with genetic distance ###\n",
    "\n",
    "    ax = fig.add_subplot(gs[0,2])\n",
    "    dist = []\n",
    "    for cross in cross_order:\n",
    "        dist.append(parents_dist[cross])\n",
    "    ax.scatter(dist, df1.loc[cross_order, 'ratio'], color=[cross_color[cross] for cross in cross_order])\n",
    "\n",
    "    lr = stats.linregress(dist, df1.loc[cross_order, 'ratio'])\n",
    "    X = (0,0.15)\n",
    "    ax.plot(X, [(x*lr.slope)+lr.intercept for x in X], c='k', zorder=-1)\n",
    "    ax.text(0.65, 0.45, f'r={lr.rvalue:.2f}\\np={plot_pval_text(lr.pvalue)}', color='k', transform=ax.transAxes)\n",
    "\n",
    "    if plot_intraspecific:\n",
    "        lr = stats.linregress(dist[:-2], df1.loc[list(cross_order)[:-2], 'ratio'])\n",
    "        X = (0,0.04)\n",
    "        ax.plot(X, [(x*lr.slope)+lr.intercept for x in X], c='red', zorder=-1)\n",
    "        ax.text(0.3, 0.7, f'r={lr.rvalue:.2f}\\np={plot_pval_text(lr.pvalue)}', color='red', transform=ax.transAxes)\n",
    "\n",
    "    #ax.set_xlabel('parental divergence')\n",
    "    ax.set_xlabel('Parental divergence\\n(subs site$^{-1}$)')\n",
    "    ax.set_ylabel('% deleted mtDNAs')\n",
    "\n",
    "    ### Relation between mtDNA completeness and respiration ###\n",
    "\n",
    "    growth_dat = []\n",
    "    for s in S:\n",
    "        s = s.split('.')[-1]\n",
    "        if s in GDR.index:\n",
    "            growth_dat.append(GDR.loc[s, cond_order])\n",
    "        else:\n",
    "            growth_dat.append(np.repeat(np.nan, 4))\n",
    "    growth_dat = pd.DataFrame(growth_dat, index=S, columns=cond_order)\n",
    "    df = df.set_index('filename').loc[S]\n",
    "    df = pd.concat([df, growth_dat], axis=1)\n",
    "    df = pd.melt(df, id_vars=['strain','passage','strain_passage','cross','complete'],\n",
    "                 value_vars=cond_order, var_name='cond', value_name='AUC').set_index('strain_passage')\n",
    "\n",
    "    mwu_growth_complete = []\n",
    "    for (cross, cond), df1 in df.loc[~df['AUC'].isna()].groupby(['cross','cond']):\n",
    "        s_u = np.nan\n",
    "        s_v = np.nan\n",
    "        u = df1.loc[df1['complete']==True, 'AUC']\n",
    "        if u.shape[0] > 0:\n",
    "            s_u = (u-u.median()).abs().sort_values().index[0]\n",
    "        v = df1.loc[df1['complete']==False, 'AUC']\n",
    "        if v.shape[0] > 0:\n",
    "            s_v = (v-v.median()).abs().sort_values().index[0]\n",
    "        if u.shape[0] > 0 and v.shape[0] > 0:\n",
    "            U, pval = stats.mannwhitneyu(u, v)\n",
    "            mwu_growth_complete.append([cond, cross, U, pval, s_u, s_v])\n",
    "        else:\n",
    "            mwu_growth_complete.append([cond, cross, np.nan, np.nan, s_u, s_v])\n",
    "    mwu_growth_complete = pd.DataFrame(mwu_growth_complete, columns=['cond', 'cross', 'U', 'pval', 's_u', 's_v'])\n",
    "    mwu_growth_complete.loc[~mwu_growth_complete['pval'].isna(), 'pval_corr'] = \\\n",
    "    multipletests(mwu_growth_complete.loc[~mwu_growth_complete['pval'].isna(), 'pval'], method='fdr_bh')[1]\n",
    "    mwu_growth_complete.set_index(['cond','cross'], inplace=True)\n",
    "\n",
    "    gs2 = plt.GridSpec(ncols=2, nrows=3, height_ratios=[2.2,2,2], wspace=0.2, hspace=0.45,\n",
    "                      left=0.07, right=0.97, top=0.96, bottom=0.06)\n",
    "\n",
    "    cond_ax = dict(zip(cond_order, [(1,0), (1,1), (2,0), (2,1)]))\n",
    "    for cond, df1 in df.groupby('cond'):\n",
    "        ax = fig.add_subplot(gs2[cond_ax[cond]])\n",
    "        sns.violinplot(x='cross', y='AUC', hue='complete', scale='width', cut=0, palette={True:'white', False:'grey'}, linewidth=1,\n",
    "                       data=df1, ax=ax, order=cross_order, hue_order=[True, False])\n",
    "        for cross, x in cross_order.items():\n",
    "            pval, s_u, s_v = mwu_growth_complete.loc[(cond, cross), ['pval_corr', 's_u', 's_v']]\n",
    "            ax.text(x, 40, plot_pval_symbol(pval), size=12, ha='center', va='center')\n",
    "            for s, x in zip([s_u, s_v], [x-0.24, x+0.24]):\n",
    "                if not pd.isna(s):\n",
    "                    img = plt.imread(f'/mnt/HDD3/mito_ma/results/spot_crops/singles/{s}_{cond}.png')\n",
    "                    imagebox = OffsetImage(img, zoom=0.08)\n",
    "                    ab = AnnotationBbox(imagebox, (x, -4), pad=0, frameon=False)\n",
    "                    ax.add_artist(ab)\n",
    "\n",
    "        ax.set_title(cond_alias[cond], size=14)\n",
    "        ax.legend_.remove()\n",
    "        ax.set_ylim(-8,42)\n",
    "        ax.set_xlabel('')\n",
    "        ax.set_xticklabels(cross_order, rotation=30, ha='right')\n",
    "        if cond == 'YPD_25':\n",
    "            legend_elms = [Line2D([0], [0], color='w', marker='s', mfc=mfc, mec='k', mew=1, ms=12, label=l) \n",
    "                           for (l, mfc) in zip(['complete mtDNAs', 'deleted mtDNAs'], ['white','grey'])]\n",
    "            ax.legend(handles=legend_elms, loc=2, bbox_to_anchor=(0.1,0.6), frameon=False)\n",
    "\n",
    "    sns.despine()\n",
    "\n",
    "    fig.text(0.02, 0.96, 'A', size=24, weight='bold')\n",
    "    fig.text(0.35, 0.96, 'B', size=24, weight='bold')\n",
    "    fig.text(0.68, 0.96, 'C', size=24, weight='bold')\n",
    "    fig.text(0.02, 0.63, 'D', size=24, weight='bold')\n",
    "\n",
    "    #if pis == True:\n",
    "    #    for ext in ['png','pdf','svg']:\n",
    "    #        plt.savefig(f'/home/mathieu/mhenault_landrylab/Publications/mito_ma/resubmission2_GRes/fig/Fig4{pis_alias}.{ext}', dpi=300)\n",
    "        #plt.show()\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "956f9719-afa8-4e6a-8725-c9d07116115c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# sort lines by deletion profile similarity\n",
    "STRAIN_ORDER_DELETION = {}\n",
    "\n",
    "for cross in cross_order:\n",
    "\n",
    "    strain_order = {}\n",
    "    for c, df in DBF.loc[(DBF['cross']==cross) & (DBF['threshold']==0.1)].groupby('complete'):\n",
    "        S = set(df['filename'])\n",
    "        if len(S) > 2:\n",
    "            dat = pd.concat([DEPTH_BIN[s] for s in S]).pivot_table(index='strain', columns='Bin', values='depth_median_norm', aggfunc=lambda x: x)\n",
    "            dendro = hierarchy.dendrogram(hierarchy.linkage(dat.values, metric=lambda u,v: 1-stats.pearsonr(u,v)[0]), no_plot=True)\n",
    "            strain_order[c] = [dat.index[i] for i in dendro['leaves']]\n",
    "        else:\n",
    "            strain_order[c] = list(S)\n",
    "    STRAIN_ORDER_DELETION[cross] = strain_order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e748d75e-b0e5-4615-a1b9-471c1a9cca4b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#with open('/mnt/HDD3/mito_ma/results/STRAIN_ORDER_DELETION.pkl', 'wb') as handle:\n",
    "#    pkl.dump(STRAIN_ORDER_DELETION, handle)\n",
    "with open('/mnt/HDD3/mito_ma/results/STRAIN_ORDER_DELETION.pkl', 'rb') as handle:\n",
    "    STRAIN_ORDER_DELETION = pkl.load(handle)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c9c886c-f750-4d5d-983d-1d751e99f9fc",
   "metadata": {},
   "source": [
    "## Fig S22-32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d76e45d-76c5-41af-aa74-ecc10342117b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "for cross in cross_order:\n",
    "\n",
    "    fig = plt.figure(figsize=[12,12])\n",
    "    gs = plt.GridSpec(nrows=3, ncols=3, height_ratios=[15,1,1], width_ratios=[5, 1, 0.4], wspace=0.5, hspace=0.2,\n",
    "                     top=0.93, bottom=0.03, right=0.98, left=0.09)\n",
    "\n",
    "    strain_order = STRAIN_ORDER_DELETION[cross]\n",
    "\n",
    "    if False in strain_order.keys():\n",
    "        S = strain_order[True]+strain_order[False]\n",
    "    else:\n",
    "        S = strain_order[True]\n",
    "\n",
    "    S = list(parents_dict[cross]) + S\n",
    "    dat = pd.concat([DEPTH_BIN[s] for s in S]).pivot_table(index='strain', columns='Bin', values='depth_median_norm', aggfunc=lambda x: np.log2(x+0.05))\n",
    "\n",
    "    ax = fig.add_subplot(gs[0,0])\n",
    "    HM1 = ax.imshow(dat.loc[S], cmap='viridis', vmin=-4, vmax=4,\n",
    "                    aspect='auto', interpolation='nearest')\n",
    "    \n",
    "    ax.set_title(cross, size=16)\n",
    "    ax.set_xticks(range(0,830,100))\n",
    "    ax.set_xticklabels(range(0,83,10))\n",
    "    ax.set_xlim(-0.5, 825-0.5)\n",
    "    ax.set_yticks(range(len(S)))\n",
    "    ax.set_yticklabels(ma_strains.loc[S, 'mt_hap_del'], size=7)\n",
    "\n",
    "    #deletion data\n",
    "    for y, s in enumerate(S):\n",
    "        if (s in strain_order[True]) or (s in parents_dict[cross]):\n",
    "            mec = (1,1,1,0)\n",
    "            mfc = 'k'\n",
    "        else:\n",
    "            mec = 'k'\n",
    "            mfc = 'w'\n",
    "        ax.scatter(860, y, marker='s', color=mfc, edgecolor=mec, lw=1, s=24, clip_on=False)\n",
    "    ax.text(860, len(S)+1, 'complete', rotation=90, ha='center', va='top')\n",
    "\n",
    "    # plot growth data\n",
    "    ax = fig.add_subplot(gs[0,1])\n",
    "    growth_dat = []\n",
    "    resp_dat = {}\n",
    "    for s in S:\n",
    "        sp = s.split('.')[-1]\n",
    "\n",
    "        if sp in GDR.index:\n",
    "            growth_dat.append(GDR.loc[sp, cond_order])\n",
    "            resp_dat[s] = GDR.loc[sp, 'resp']\n",
    "        else:\n",
    "            growth_dat.append(np.repeat(np.nan, 4))\n",
    "            resp_dat[s] = np.nan\n",
    "\n",
    "    growth_dat = pd.DataFrame(growth_dat, index=S, columns=gitter_pivot.columns)\n",
    "    \n",
    "    HM2 = ax.imshow(growth_dat.loc[S], cmap='magma', vmin=0, vmax=38,\n",
    "                    aspect='auto', interpolation='nearest')\n",
    "    \n",
    "    ax.set_xticks(range(4))\n",
    "    ax.set_xticklabels([cond_alias[c] for c in growth_dat.columns], rotation=90)\n",
    "    ax.set_xlim(-0.5, 3.5)\n",
    "    ax.set_yticks(range(len(S)))\n",
    "    ax.set_yticklabels(ma_strains.loc[S, 'mt_hap_del'], size=7)\n",
    "\n",
    "    #respiration data\n",
    "    for y, s in enumerate(S):\n",
    "        if (resp_dat[s] == True) or (s in parents_dict[cross]):\n",
    "            mec = (1,1,1,0)\n",
    "            mfc = 'k'\n",
    "        elif resp_dat[s] == False:\n",
    "            mec = 'k'\n",
    "            mfc = 'w'\n",
    "        else:\n",
    "            mec = (1,1,1,0)\n",
    "            mfc = (1,1,1,0)\n",
    "        ax.scatter(4.5, y, marker='s', color=mfc, edgecolor=mec, lw=1, s=24, clip_on=False)\n",
    "    ax.text(4.5, len(S)+1, 'respiration', rotation=90, ha='center', va='top')\n",
    "\n",
    "    #colony images\n",
    "    ax = fig.add_subplot(gs[0,2])\n",
    "    img = PIL.Image.open(f'/mnt/HDD3/mito_ma/results/spot_crops/{cross}_assembled.png')\n",
    "    ax.imshow(np.asarray(img))\n",
    "    \n",
    "    off_yticks = img.size[1]/len(S)\n",
    "    ax.set_yticks((np.arange(len(S))*off_yticks) + 0.5*off_yticks)\n",
    "    ax.set_yticklabels(ma_strains.loc[S, 'mt_hap_del'], size=7)\n",
    "\n",
    "    off_xticks = img.size[0]/4\n",
    "    ax.set_xticks((np.arange(4)*off_xticks) + 0.5*off_xticks)\n",
    "    ax.set_xticklabels([cond_alias[c] for c in growth_dat.columns], rotation=90, size=7)\n",
    "\n",
    "    # plot GFF entries\n",
    "    ax = fig.add_subplot(gs[1,0])\n",
    "\n",
    "    for i in ['left','right','top']:\n",
    "        ax.spines[i].set_visible(False)\n",
    "    ax.arrow(0, 1, ref_genome_length, 0, color='0.9', lw=0, width=1, head_length=0, head_width=0, zorder=-1)\n",
    "\n",
    "    legend_elms = []\n",
    "    for at in annot_type_order:\n",
    "        if at != 'gc_cluster':\n",
    "            l = annot_type_alias[at]\n",
    "            fc = annot_type_color[at]\n",
    "            lw = 0\n",
    "            if fc == 'white':\n",
    "                lw = 1\n",
    "            legend_elms.append(Line2D([0], [0], color='w', marker='s', ms=9, mfc=fc, mec='black', mew=lw, label=l))\n",
    "    ax.legend(handles=legend_elms, ncol=6, loc=9, bbox_to_anchor=(0.5, 1.4), frameon=False,\n",
    "             borderpad=0.0, labelspacing=0.2, handlelength=0.3, columnspacing=1.5)\n",
    "\n",
    "    for i in artificial_genome_feat.loc[~artificial_genome_feat['annot_type'].isin(['gc_cluster','other'])].\\\n",
    "    sort_values(by='annot_plot_order', ascending=False).index:\n",
    "        start, end, color, w, z = artificial_genome_feat.loc[i, [3,4,'annot_color','annot_width','annot_plot_order']]\n",
    "        ax.arrow(start, 1, end-start, 0, color=color, lw=0, width=w, head_length=0, head_width=0, zorder=z)\n",
    "    ax.set_xlim(xlim)\n",
    "    ax.set_ylim(0.45, 3)\n",
    "    ax.set_xticks(np.arange(0, 81e3, 1e4))\n",
    "    ax.set_xticklabels(range(0,90,10))\n",
    "    ax.set_xlabel('kb')\n",
    "    ax.set_yticks([])\n",
    "    \n",
    "    if cross in ['BA1', 'BA2']:\n",
    "        plot_rearrangement_SpA()\n",
    "\n",
    "    ax_cbar = fig.add_axes([0.28, 0.07, 0.15, 0.01])\n",
    "    cb = plt.colorbar(HM1, cax=ax_cbar, orientation='horizontal', ticks=np.linspace(-4,4,5), label='log$_2$ normalized depth of coverage')\n",
    "    cb.outline.set_visible(False)\n",
    "\n",
    "    ax_cbar = fig.add_axes([0.7, 0.07, 0.15, 0.01])\n",
    "    cb = plt.colorbar(HM2, cax=ax_cbar, orientation='horizontal', ticks=np.linspace(0,35,6), label='growth (AUC)')\n",
    "    cb.outline.set_visible(False)\n",
    "\n",
    "    fig.text(0.02, 0.95, 'A', weight='bold', size=24)\n",
    "    fig.text(0.66, 0.95, 'B', weight='bold', size=24)\n",
    "    fig.text(0.88, 0.95, 'C', weight='bold', size=24)\n",
    "    \n",
    "    #plt.savefig(f'/home/mathieu/mhenault_landrylab/Publications/mito_ma/resubmission2_GRes/fig/detailed_depth_hm_{cross}.svg', dpi=300)\n",
    "    #plt.show()\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab87b6ed-8914-4db3-b021-3b0d56fd733a",
   "metadata": {},
   "source": [
    "## Compute median depth per gene"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f0378ec5-c741-4bf0-be43-443755c91694",
   "metadata": {},
   "outputs": [],
   "source": [
    "mean_depth_genes = {}\n",
    "\n",
    "idx = 0\n",
    "with ProgressBar(max_value=len(DEPTH)) as bar:\n",
    "    for s, db in DEPTH.items():\n",
    "\n",
    "        cross = ma_strains.loc[s, 'cross']\n",
    "        if (cross in cross_order) or (cross == 'P'):\n",
    "\n",
    "            mdg = {}\n",
    "\n",
    "            db = db.copy()\n",
    "            db['func_idx'] = pos_func_annot.loc[db['pos']].values\n",
    "            db['Name'] = artificial_genome_feat.loc[db['func_idx'], 'Name'].values\n",
    "            #collapse them gene annotations\n",
    "            db['Name'] = np.where(db['Name'].apply(lambda x: x[:5]=='cob-E'), 'cob', db['Name'])\n",
    "            db['Name'] = np.where(db['Name'].apply(lambda x: x[:6]=='cox1-E'), 'cox1', db['Name'])\n",
    "            db['Name'] = np.where(db['Name'].apply(lambda x: x[:5]=='rnl-e'), 'rnl', db['Name'])\n",
    "            db['Name'] = np.where(db['Name'].apply(lambda x: x[:3]=='trn'), 'trna', db['Name'])\n",
    "\n",
    "            for name, df in db.groupby('Name'):\n",
    "                mdg[name] = df['depth'].median()/depth_nuclear.loc[s, 'median']\n",
    "\n",
    "            mean_depth_genes[s] = pd.Series(mdg)\n",
    "\n",
    "        idx += 1\n",
    "        bar.update(idx)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6bf545c-34a8-4a79-a6f0-bbd5bf518c43",
   "metadata": {},
   "source": [
    "## Fig 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5829813e-e645-4829-a8a3-2285d45b5b6d",
   "metadata": {},
   "outputs": [],
   "source": [
    "MDG_GITTER = {}\n",
    "\n",
    "fig = plt.figure(figsize=[9,9])\n",
    "gs = plt.GridSpec(ncols=4, nrows=3, hspace=0.6, wspace=0.05, left=0.02, right=0.98, bottom=0.1, top=0.96)\n",
    "\n",
    "cross_ax_dict = dict(zip(cross_order, itertools.product(range(3), range(4))))\n",
    "\n",
    "for cross, df in ma_strains.loc[ma_strains['mtdel_filter']].groupby('cross'):\n",
    "    strain_order = STRAIN_ORDER_DELETION[cross]\n",
    "    \n",
    "    if False in strain_order:\n",
    "        S = strain_order[True] + strain_order[False]\n",
    "    else:\n",
    "        S = strain_order[True]\n",
    "    \n",
    "    S = list(parents_dict[cross]) + S\n",
    "    \n",
    "    # coverage depth data\n",
    "    depth_dat = pd.concat([mean_depth_genes[s] for s in S], axis=1).T\n",
    "    depth_dat.index = S\n",
    "    depth_dat = depth_dat.loc[S, genes_to_display]\n",
    "\n",
    "    depth_dat = depth_dat.applymap(lambda x: np.log2(x+0.05))\n",
    "    \n",
    "    # growth data\n",
    "    growth_dat = []\n",
    "    for s in S:\n",
    "        s = s.split('.')[-1]\n",
    "        if s in gitter_pivot.index:\n",
    "            growth_dat.append(gitter_pivot.loc[s])\n",
    "        else:\n",
    "            growth_dat.append(np.repeat(np.nan, 4))\n",
    "        \n",
    "    growth_dat = pd.DataFrame(growth_dat, index=S, columns=gitter_pivot.columns)\n",
    "    \n",
    "    dat = pd.concat([depth_dat, growth_dat], axis=1)\n",
    "    \n",
    "    MDG_GITTER[cross] = dat\n",
    "    \n",
    "    #plot\n",
    "\n",
    "    ax = fig.add_subplot(gs[cross_ax_dict[cross]])\n",
    "    \n",
    "    mask = np.ndarray(dat.shape)\n",
    "    mask[:, :-4] = False\n",
    "    mask[:, -4:] = True\n",
    "    hm = np.ma.MaskedArray(dat, mask)\n",
    "    HM1 = ax.imshow(hm, aspect='auto', interpolation='nearest', cmap='viridis', vmin=-4, vmax=4)\n",
    "    \n",
    "    mask = np.ndarray(dat.shape)\n",
    "    mask[:, :-4] = True\n",
    "    mask[:, -4:] = False\n",
    "    hm = np.ma.MaskedArray(dat, mask)\n",
    "    HM2 = ax.imshow(hm, aspect='auto', interpolation='nearest', cmap='magma', vmin=0, vmax=38)\n",
    "\n",
    "    ax.axvline(11.5, color='white', lw=2, zorder=2)\n",
    "    \n",
    "    ax.set_xticks(range(16))\n",
    "    ax.set_xticklabels([genes_alias[i] for i in genes_to_display] + [cond_alias[i] for i in growth_dat.columns], rotation=90, size=9)\n",
    "    ax.set_yticks([])\n",
    "    \n",
    "    ax.spines['top'].set_visible(False)\n",
    "    ax.spines['left'].set_visible(False)\n",
    "    ax.spines['right'].set_visible(False)\n",
    "    ax.spines['bottom'].set_visible(False)\n",
    "    \n",
    "    ax.set_title(cross, size=14)\n",
    "    \n",
    "    for y, s in enumerate(S[:2]):\n",
    "        ax.plot([-0.5, -1.5], [y, 5*y], color='k', clip_on=False, lw=0.5, zorder=0.5)\n",
    "        ax.scatter(-1.5, 5*y, s=24, color=parents_color[s.split('.')[-1]], clip_on=False, zorder=1)\n",
    "\n",
    "ax_cbar = fig.add_axes([0.78, 0.25, 0.15, 0.015])\n",
    "cb = plt.colorbar(HM1, cax=ax_cbar, orientation='horizontal', ticks=np.linspace(-4,4,5), label='log$_2$ normalized\\ndepth of coverage')\n",
    "cb.outline.set_visible(False)\n",
    "\n",
    "ax_cbar = fig.add_axes([0.78, 0.12, 0.15, 0.015])\n",
    "cb = plt.colorbar(HM2, cax=ax_cbar, orientation='horizontal', ticks=np.linspace(0,35,6), label='growth (AUC)')\n",
    "cb.outline.set_visible(False)\n",
    "\n",
    "#for ext in ['svg','pdf','png']:\n",
    "#    plt.savefig(f'/home/mathieu/mhenault_landrylab/Publications/mito_ma/resubmission2_GRes/fig/Fig5.{ext}', dpi=300)\n",
    "\n",
    "#plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2afd8f0d-1c5d-48b9-a98a-5350aafeecaf",
   "metadata": {},
   "source": [
    "# Associations between aspects of mtDNA evolution\n",
    "## Parse nuclear vcf files from Fijarczyk et al. 2021"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2cfe910-a04e-435c-8040-09c0ec877db1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import raw vcf files\n",
    "VCF_MELT_NUC = {}\n",
    "\n",
    "for cross in cross_order:\n",
    "    path = f'/mnt/HDD1/Dropbox/denovo_mut/data/denovo_vcf/var_{cross}.fil.vcf.gz'\n",
    "    vcf = pd.read_csv(path, comment='#', compression='gzip', sep='\\t')\n",
    "    with gzip.open(path) as handle:\n",
    "        for line in handle.readlines():\n",
    "            if b'#CHROM' in line:\n",
    "                header = line.decode().strip('\\n').split('\\t')\n",
    "                break\n",
    "    vcf.columns = header\n",
    "    samples = vcf.columns[9:]\n",
    "    #randomly subsample 10k variants\n",
    "    variants = np.random.choice(vcf.index, 10000)\n",
    "    vcf = vcf.loc[variants]\n",
    "    vcf['var_uid'] = [f'v{i}' for i in range(vcf.shape[0])]\n",
    "    vcf_melt = pd.melt(vcf, id_vars=['var_uid','FORMAT'], value_vars=vcf.columns[9:], var_name='filename', value_name='GT')\n",
    "    vcf_melt['#CHROM'] = vcf.set_index('var_uid').loc[vcf_melt['var_uid'], '#CHROM'].values\n",
    "    vcf_melt['#POS'] = vcf.set_index('var_uid').loc[vcf_melt['var_uid'], 'POS'].values\n",
    "    \n",
    "    for f, df in vcf_melt.groupby('FORMAT'):\n",
    "        Format = f.split(':')\n",
    "        for i,tag in enumerate(Format):\n",
    "            new = df['GT'].apply(lambda x: x.split(':')[i]).replace('.', np.nan)\n",
    "            if tag in ['DP','AO','RO']:\n",
    "                new = new.astype(float)\n",
    "            vcf_melt.loc[df.index, tag.lower()] = new\n",
    "    \n",
    "    VCF_MELT_NUC[cross] = vcf_melt\n",
    "    print(cross)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bfaa749a-b7cd-4831-8ac1-00cf15416621",
   "metadata": {},
   "outputs": [],
   "source": [
    "for cross in cross_order:\n",
    "    if cross not in ['BSc1', 'BSc2']:\n",
    "        vcf_melt = VCF_MELT_NUC[cross]\n",
    "        p1, p2 = [p.split('.')[-1] for p in parents_dict[cross]]\n",
    "        idx = 0\n",
    "\n",
    "        with ProgressBar(max_value=10000) as bar:\n",
    "            for v, df in vcf_melt.groupby('var_uid'):\n",
    "                a1 = set(df.set_index('filename').loc[p1, 'gt'].split('/'))\n",
    "                a2 = set(df.set_index('filename').loc[p2, 'gt'].split('/'))\n",
    "\n",
    "                allele_order = np.nan\n",
    "                if a1 == {'0'} and a2 == {'1'}:\n",
    "                    allele_order = 0\n",
    "                elif a1 == {'1'} and a2 == {'0'}:\n",
    "                    allele_order = 1\n",
    "\n",
    "                vcf_melt.loc[df.index, 'allele_order'] = allele_order\n",
    "\n",
    "                idx += 1\n",
    "                bar.update(idx)\n",
    "\n",
    "        for o, df in vcf_melt.groupby('allele_order'):\n",
    "            if o == 0:\n",
    "                vcf_melt.loc[df.index, p1] = df['ad'].apply(lambda x: x.split(',')[0])\n",
    "                vcf_melt.loc[df.index, p2] = df['ad'].apply(lambda x: x.split(',')[1])\n",
    "            elif o == 1:\n",
    "                vcf_melt.loc[df.index, p1] = df['ad'].apply(lambda x: x.split(',')[1])\n",
    "                vcf_melt.loc[df.index, p2] = df['ad'].apply(lambda x: x.split(',')[0])\n",
    "        VCF_MELT_NUC[cross] = vcf_melt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cfd83f59-5170-4068-8e6d-e07e31d60c83",
   "metadata": {},
   "outputs": [],
   "source": [
    "#parse chromosome offset values for reference nuclear genomes\n",
    "tig_offset = {cross:{} for cross in cross_order}\n",
    "\n",
    "offset = 0\n",
    "with open('/home/mathieu/paradoxus_nanopore/paradoxus4/assemblies/paradoxus4_bc02_smartdenovo_pilon-nanopolish_reordered.fasta') as handle:\n",
    "    for seq in SeqIO.parse(handle, 'fasta'):\n",
    "        for cross in ['BB1','BB2','BC1','BC2','BA1','BA2']:\n",
    "            tig_offset[cross][seq.id] = offset\n",
    "        offset += len(seq.seq)\n",
    "            \n",
    "offset = 0\n",
    "with open('/home/mathieu/paradoxus_nanopore/paradoxus4/assemblies/paradoxus4_bc03_smartdenovo_pilon-nanopolish_reordered.fasta') as handle:\n",
    "    for seq in SeqIO.parse(handle, 'fasta'):\n",
    "        for cross in ['CC1','CC2','CC3']:\n",
    "            tig_offset[cross][seq.id] = offset\n",
    "        offset += len(seq.seq)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85f0d5e5-a2d3-4366-a3d0-98ddab70dfcc",
   "metadata": {},
   "source": [
    "## Inspect allelic ratios along nuclear chromosomes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "343417c7-8105-4c4d-81b7-3e76206134e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "depth_per_chrom = []\n",
    "for cross in cross_order:\n",
    "    \n",
    "    vcf_melt = VCF_MELT_NUC[cross]\n",
    "    dpc = pd.DataFrame(vcf_melt.groupby(['filename','#CHROM'])['dp'].median())\n",
    "    for s, df in vcf_melt.groupby('filename'):\n",
    "        dpc.loc[s, 'median_dp'] = df['dp'].median()\n",
    "    dpc = dpc.reset_index()\n",
    "    dpc['cross'] = cross\n",
    "    depth_per_chrom.append(dpc)\n",
    "    \n",
    "depth_per_chrom = pd.concat(depth_per_chrom).reset_index(drop=True)\n",
    "\n",
    "depth_per_chrom['line'] = depth_per_chrom['filename'].apply(lambda x: x.split('_')[0])\n",
    "for s, df in depth_per_chrom.groupby('filename'):\n",
    "    if len(s.split('_')) == 2:\n",
    "        depth_per_chrom.loc[df.index, 'passage'] = int(s.split('_')[1].strip('P'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ccb5be1e-e93a-4c58-8400-1f6b92688e1b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#import table with copy number calls per chromosome from Fijarczyk et al. 2021\n",
    "fijarczyk_S4 = pd.read_csv('/home/mathieu/mhenault_landrylab/papiers/fijarczyk_gbe2021_SUPP/TableS4_fijarczyk_gbe2021.csv', skiprows=3, header=None)\n",
    "fijarczyk_S4.columns = ['cross','line','tig','chrom','n_mut','gen','cn_Tini','cn_Tend','mean_cn','fil_len','fil_len*cn']\n",
    "for s, df in fijarczyk_S4.groupby('line'):\n",
    "    fijarczyk_S4.loc[df.index, 'major_cn_Tini'] = np.round((df['fil_len']*df['cn_Tini']).sum()/df['fil_len'].sum())\n",
    "    fijarczyk_S4.loc[df.index, 'major_cn_Tend'] = np.round((df['fil_len']*df['cn_Tend']).sum()/df['fil_len'].sum())\n",
    "    \n",
    "\n",
    "fijarczyk_S4.set_index(['line','tig'], inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93d2b262-96ff-4e8a-bfd0-d8949abd0488",
   "metadata": {},
   "outputs": [],
   "source": [
    "tig_chrom = {}\n",
    "for cross, df in fijarczyk_S4.groupby('cross'):\n",
    "    tig_chrom[cross] = df.groupby('tig').apply(lambda x: x.iloc[0]['chrom'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "76d053c1-cec1-4850-b021-aad431af0ab0",
   "metadata": {},
   "outputs": [],
   "source": [
    "for (s, p, tig), df in depth_per_chrom.groupby(['line','passage','#CHROM']):\n",
    "    if s in fijarczyk_S4.index:\n",
    "        if p == 1:\n",
    "            depth_per_chrom.loc[df.index, 'cn'] = fijarczyk_S4.loc[(s,tig), 'cn_Tini']\n",
    "            depth_per_chrom.loc[df.index, 'major_cn'] = fijarczyk_S4.loc[(s,tig), 'major_cn_Tini']\n",
    "        if p > 16:\n",
    "            depth_per_chrom.loc[df.index, 'cn'] = fijarczyk_S4.loc[(s,tig), 'cn_Tend']\n",
    "            depth_per_chrom.loc[df.index, 'major_cn'] = fijarczyk_S4.loc[(s,tig), 'major_cn_Tend']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34efc36a-7b3b-4ecc-b51d-bcc27c86a1c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "depth_per_chrom['cn_ratio'] = depth_per_chrom['cn']/depth_per_chrom['major_cn']\n",
    "depth_per_chrom['dp_ratio'] = depth_per_chrom['dp']/depth_per_chrom['median_dp']\n",
    "depth_per_chrom['ratio_dev'] = depth_per_chrom['dp_ratio']-depth_per_chrom['cn_ratio']\n",
    "for cross, df in depth_per_chrom.groupby('cross'):\n",
    "    depth_per_chrom.loc[df.index, 'chrom'] = tig_chrom[cross].loc[df['#CHROM']].values\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df14ab0d-139b-4410-bfd4-9746532dedc9",
   "metadata": {},
   "outputs": [],
   "source": [
    "dpc_mean = pd.concat([depth_per_chrom.groupby(['filename','cross','line','passage']).apply(lambda x: np.mean(np.abs(x['ratio_dev']))).rename('mean_ratio_dev'),\n",
    "                      depth_per_chrom.groupby(['filename','cross','line','passage']).apply(lambda x: np.median(x['median_dp'])).rename('median_dp')], axis=1).reset_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87b16f11-9941-4db8-8529-e08eec63290d",
   "metadata": {},
   "outputs": [],
   "source": [
    "for [cross, p], df in dpc_mean.loc[~dpc_mean['mean_ratio_dev'].isna()].groupby(['cross','passage']):\n",
    "    #t = np.quantile(df['mean_ratio_dev'], 0.9)\n",
    "    dpc_mean.loc[df.index, 'high_ratio_dev'] = df['mean_ratio_dev'] >= 0.08"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a42306b6-4437-464e-a21e-0304a342d2cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "#import pcr data\n",
    "pcr_markers = pd.read_csv('/home/mathieu/mhenault_landrylab/Experiments/screen_glycerol/pcr_validation/pcr_markers.csv')\n",
    "\n",
    "pcr_markers['strain_passage'] = pcr_markers.apply(lambda x: f'{x[\"strain\"]}_P{x[\"passage\"]}', axis=1)\n",
    "pcr_markers.set_index('strain_passage', inplace=True)\n",
    "\n",
    "for sp in pcr_markers.index:\n",
    "    if np.all(pcr_markers.loc[sp, ['atp6','rnl','mat']] == 0):\n",
    "        pcr_markers.loc[sp, ['atp6','rnl','mat']] = np.repeat(np.nan, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7fd4366-7bb0-4922-8352-1347c168b089",
   "metadata": {},
   "source": [
    "## Fig S39"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "965770fa-7c84-4c29-b41d-567bb3d89227",
   "metadata": {},
   "outputs": [],
   "source": [
    "chrom_order = ['chrI','chrII','chrIII','chrIV','chrV','chrVI','chrVII','chrVIII','chrIX','chrX','chrXI','chrXII','chrXIII','chrXIV','chrXV','chrXVI']\n",
    "pcr_marker_color = {0:'red', 1:'white'}\n",
    "\n",
    "\n",
    "cross = 'BA2'\n",
    "    \n",
    "fig = plt.figure(figsize=[10,7])\n",
    "gs = plt.GridSpec(ncols=4, nrows=1, width_ratios=[16,16,12,4], wspace=0.4, left=0.08, right=0.96, top=0.93, bottom=0.25)\n",
    "\n",
    "dat_cross = depth_per_chrom.loc[(depth_per_chrom['passage']==1) & \n",
    "                                (depth_per_chrom['cross']==cross) & \n",
    "                                ~(depth_per_chrom['cn'].isna())]\n",
    "S = ma_strains.loc[(ma_strains['cross']==cross) & (ma_strains['passage']==1) & (ma_strains['identity_filter']==True)]\n",
    "S = S.groupby('strain').apply(lambda x: x.iloc[0]['filename'])\n",
    "strain_order = dat_cross.groupby('line').apply(lambda x: np.mean(np.abs(x['ratio_dev']))).sort_values().index\n",
    "strain_order = [s for s in S.index if s not in strain_order] + [s for s in strain_order if s in S]\n",
    "\n",
    "ax = fig.add_subplot(gs[0])\n",
    "\n",
    "dat = dat_cross.pivot_table(index='line', columns='chrom', values='ratio_dev', aggfunc=lambda x: np.mean(x))\n",
    "for s in strain_order:\n",
    "    if s not in dat.index:\n",
    "        dat.loc[s] = np.nan\n",
    "\n",
    "HM1 = ax.imshow(dat.loc[strain_order, chrom_order], cmap='bwr', aspect='auto', interpolation='nearest', vmin=-0.5, vmax=0.5)\n",
    "ax.set_yticks(range(len(strain_order)))\n",
    "ax.set_yticklabels(strain_order)\n",
    "ax.set_xticks(range(16))\n",
    "ax.set_xticklabels(chrom_order, rotation=90)\n",
    "\n",
    "\n",
    "ax = fig.add_subplot(gs[1])\n",
    "\n",
    "dat = dat_cross.pivot_table(index='line', columns='chrom', values='cn', aggfunc=lambda x: np.mean(x))\n",
    "for s in strain_order:\n",
    "    if s not in dat.index:\n",
    "        dat.loc[s] = np.nan\n",
    "HM2 = ax.imshow(dat.loc[strain_order, chrom_order], cmap='binary', aspect='auto', interpolation='nearest', vmin=0, vmax=4)\n",
    "\n",
    "ax.set_yticks(range(len(strain_order)))\n",
    "ax.set_yticklabels(strain_order)\n",
    "ax.set_xticks(range(16))\n",
    "ax.set_xticklabels(chrom_order, rotation=90)   \n",
    "\n",
    "# add mito variables \n",
    "# coverage depth data\n",
    "ax = fig.add_subplot(gs[2])\n",
    "\n",
    "depth_dat = []\n",
    "for s in strain_order:\n",
    "    if S.loc[s] in mean_depth_genes:\n",
    "        depth_dat.append(mean_depth_genes[S.loc[s]])\n",
    "    else:\n",
    "        depth_dat.append(pd.Series(np.repeat(np.nan, 12), index=genes_to_display))\n",
    "depth_dat = pd.concat(depth_dat, axis=1).T\n",
    "#pd.concat([mean_depth_genes[S.loc[s]] for s in strain_order], axis=1).T\n",
    "depth_dat.index = strain_order\n",
    "depth_dat = depth_dat.loc[strain_order, genes_to_display]\n",
    "depth_dat = depth_dat.applymap(lambda x: np.log2(x+0.05))\n",
    "\n",
    "HM3 = ax.imshow(depth_dat, aspect='auto', interpolation='nearest', cmap='viridis',\n",
    "         vmin=-4, vmax=4)\n",
    "if cross == 'BA2':\n",
    "    for y, s in enumerate(strain_order):\n",
    "        sp = S[s].split('.')[-1]\n",
    "        if sp in pcr_markers.index:\n",
    "            atp6 = pcr_markers.loc[sp, 'atp6']\n",
    "            if not np.isnan(atp6):\n",
    "                ax.scatter(0, y, color=pcr_marker_color[atp6], s=12)\n",
    "            rnl = pcr_markers.loc[sp, 'rnl']\n",
    "            if not np.isnan(rnl):\n",
    "                ax.scatter(4, y, color=pcr_marker_color[rnl], s=12)\n",
    "\n",
    "ax.set_yticks(range(len(strain_order)))\n",
    "ax.set_yticklabels(strain_order)\n",
    "ax.set_xticks(range(12))\n",
    "ax.set_xticklabels([genes_alias[i] for i in genes_to_display], rotation=90) \n",
    "\n",
    "# growth data\n",
    "ax = fig.add_subplot(gs[3])\n",
    "growth_dat = gitter_pivot.loc[[f'{s}_P1' for s in strain_order]]\n",
    "\n",
    "HM4 = ax.imshow(growth_dat, aspect='auto', interpolation='nearest', cmap='magma', vmin=0, vmax=38)\n",
    "ax.set_yticks(range(len(strain_order)))\n",
    "ax.set_yticklabels(strain_order)\n",
    "ax.set_xticks(range(4))\n",
    "ax.set_xticklabels([cond_alias[i] for i in growth_dat.columns], rotation=90)\n",
    "\n",
    "\n",
    "ax_cbar1 = fig.add_axes([0.12, 0.1, 0.15, 0.02])\n",
    "cb = plt.colorbar(HM1, cax=ax_cbar1, orientation='horizontal', ticks=np.linspace(-0.5,0.5,5), label='depth of coverage\\ndeviation')\n",
    "cb.outline.set_visible(False)\n",
    "\n",
    "ax_cbar2 = fig.add_axes([0.4, 0.1, 0.15, 0.015])\n",
    "cb = plt.colorbar(HM2, cax=ax_cbar2, orientation='horizontal', ticks=np.arange(0,5), label='called CN')\n",
    "cb.outline.set_visible(False)\n",
    "\n",
    "ax_cbar3 = fig.add_axes([0.67, 0.1, 0.15, 0.015])\n",
    "cb = plt.colorbar(HM3, cax=ax_cbar3, orientation='horizontal', ticks=np.linspace(-4,4,5), label='log$_2$ normalized\\ndepth of coverage')\n",
    "cb.outline.set_visible(False)\n",
    "\n",
    "ax_cbar4 = fig.add_axes([0.9, 0.1, 0.07, 0.015])\n",
    "cb = plt.colorbar(HM4, cax=ax_cbar4, orientation='horizontal', ticks=np.linspace(0,38,3), label='growth (AUC)')\n",
    "cb.outline.set_visible(False)\n",
    "\n",
    "fig.text(0.02, 0.95, 'A', weight='bold', size=24)\n",
    "fig.text(0.32, 0.95, 'B', weight='bold', size=24)\n",
    "fig.text(0.62, 0.95, 'C', weight='bold', size=24)\n",
    "fig.text(0.85, 0.95, 'D', weight='bold', size=24)\n",
    "\n",
    "ax = fig.axes[5]\n",
    "ax.set_xlim(1,4)\n",
    "\n",
    "#plt.savefig(f'/home/mathieu/mhenault_landrylab/Publications/mito_ma/resubmission2_GRes/fig/depth_hm_nucCN_{cross}.svg', dpi=300)\n",
    "#plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2af97df9-12be-40c3-8075-dfbe54dd9ae0",
   "metadata": {},
   "source": [
    "## Fig S40"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "282bbaa8-328a-45c8-b755-2cab50401fc1",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=[7,7])\n",
    "gs = plt.GridSpec(ncols=2, nrows=2, hspace=0.4, wspace=0.5, left=0.1, right=0.97, top=0.85, bottom=0.08)\n",
    "\n",
    "for p, df in dpc_mean.loc[(~dpc_mean['cross'].isin(['BSc1','BSc2'])) &\n",
    "                         (~dpc_mean['median_dp'].isna()) & \n",
    "                         (~dpc_mean['mean_ratio_dev'].isna())].groupby('passage'):\n",
    "    if p == 1:\n",
    "        ax = ax_idx = 0\n",
    "        pa = 'initial timepoint'\n",
    "    elif p == 35:\n",
    "        ax = ax_idx = 1\n",
    "        pa = 'final timepoint'\n",
    "    else:\n",
    "        continue\n",
    "        \n",
    "    ax = fig.add_subplot(gs[0, ax_idx])\n",
    "    for cross, df1 in df.groupby('cross'):\n",
    "        ax.plot(df1['mean_ratio_dev'].sort_values(), np.linspace(0,1,df1.shape[0]), color=cross_color[cross])\n",
    "    ax.set_title(pa, size=14)\n",
    "    ax.set_xlabel('mean ratio deviation')\n",
    "    ax.set_ylabel('cumul')\n",
    "    ax.set_xlim(0, 0.14)\n",
    "    \n",
    "    ax = fig.add_subplot(gs[1, ax_idx])\n",
    "    df = df.sample(frac=1)\n",
    "    \n",
    "    ax.scatter(df['median_dp'], df['mean_ratio_dev'], c=df['cross'].apply(lambda x: cross_color[x]), s=12)\n",
    "    \n",
    "    lr = stats.linregress(df['median_dp'], df['mean_ratio_dev'])\n",
    "    X = np.array([0,200])\n",
    "    ax.plot(X, np.apply_along_axis(lambda x: x*lr.slope+lr.intercept, 0, X), color='black', zorder=1)\n",
    "    ax.text(0.72, 0.78, f'r={lr.rvalue:.3f}\\np={plot_pval_text(lr.pvalue)}', transform=ax.transAxes)\n",
    "    \n",
    "    ax.set_title(pa, size=14)\n",
    "    ax.set_xlabel('median depth of coverage (X)')\n",
    "    ax.set_ylabel('mean ratio deviation')\n",
    "    \n",
    "\n",
    "fig.text(0.03, 0.88, 'A', weight='bold', size=24)\n",
    "fig.text(0.03, 0.42, 'B', weight='bold', size=24)\n",
    "\n",
    "ax_legend = fig.add_axes([0.15,0.9,0.7,0.1])\n",
    "ax_legend.axis('off')\n",
    "legend_elms = [Line2D([0], [0], color=cross_color[c], label=c) for c in cross_order]\n",
    "ax_legend.legend(handles=legend_elms, loc=2, bbox_to_anchor=(0,1), ncol=5, frameon=False)\n",
    "    \n",
    "sns.despine()\n",
    "#plt.savefig('/home/mathieu/mhenault_landrylab/Publications/mito_ma/resubmission2_GRes/fig/ratio_dev_depth.svg', dpi=300)\n",
    "#plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc594679-d74e-4f27-803e-901459a96559",
   "metadata": {},
   "source": [
    "## Build a table integrating all the variables of interest per line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "127c46b4-5a44-4f40-979a-88cf83a0c255",
   "metadata": {},
   "outputs": [],
   "source": [
    "combined_drr = []\n",
    "for cross, df in ma_strains.groupby('cross'):\n",
    "    if cross in cross_order:\n",
    "        for fn in df['filename'].values:\n",
    "            \n",
    "            sp = fn.split('.')[-1]\n",
    "            s, p = sp.split('_')\n",
    "            p = int(p.strip('P'))\n",
    "            fnr = fn\n",
    "            \n",
    "            # correct fn for clones\n",
    "            if ma_strains.loc[fn, 'mt_haplotype'] == 'clone':\n",
    "                fn_list = ma_strains.loc[(ma_strains['strain']==s) & (ma_strains['mt_haplotype']!='clone'), 'filename']\n",
    "                if fn_list.shape[0] == 1:\n",
    "                    fnr = fn_list.iloc[0]\n",
    "                elif fn == 'HI.4802.001.N708---N506.B40_P1':\n",
    "                    fnr = 'NS.1250.002.N704---N507.B40_P35'\n",
    "                elif fn == 'NS.1249.002.N712---N504.B55_P10':\n",
    "                    fnr = 'NS.1250.002.N705---N508.B55_P35'\n",
    "     \n",
    "            deletion = np.nan\n",
    "            recomb = np.nan\n",
    "            respiration = np.nan\n",
    "            mito_inst = np.nan\n",
    "            nuc_inst = np.nan\n",
    "            mean_ratio_dev = np.nan\n",
    "            \n",
    "            # deletion\n",
    "            if fn in STRAIN_ORDER_DELETION[cross][True]:\n",
    "                deletion = False\n",
    "            elif False in STRAIN_ORDER_DELETION[cross]:\n",
    "                if fn in STRAIN_ORDER_DELETION[cross][False]:\n",
    "                    deletion = True\n",
    "            \n",
    "            # recomb\n",
    "            if fnr in REC['strain'].values:\n",
    "                if REC.set_index('strain').loc[fnr, 'count'] > 0:\n",
    "                    recomb = True\n",
    "                else:\n",
    "                    recomb = False\n",
    "            \n",
    "            #respiration\n",
    "            if sp in GDR.index:\n",
    "                respiration = GDR.loc[sp, 'resp']\n",
    "\n",
    "            #mito instability\n",
    "            if (respiration == True and deletion == True) or (respiration == False and deletion == False):\n",
    "                mito_inst = True\n",
    "            elif (respiration == True and deletion == False) or (respiration == False and deletion == True):\n",
    "                mito_inst = False\n",
    "                \n",
    "            #nuc instability\n",
    "            if cross not in ['BSc1', 'BSc2']:\n",
    "                if sp in dpc_mean['filename'].values:\n",
    "                    if dpc_mean.set_index('filename').loc[sp, 'high_ratio_dev'] == True:\n",
    "                        nuc_inst = True\n",
    "                    if dpc_mean.set_index('filename').loc[sp, 'high_ratio_dev'] == False:\n",
    "                        nuc_inst = False\n",
    "                    mean_ratio_dev = dpc_mean.set_index('filename').loc[sp, 'mean_ratio_dev']\n",
    "            combined_drr.append([s, p, cross, deletion, recomb, respiration, mito_inst, nuc_inst, mean_ratio_dev])\n",
    "            \n",
    "combined_drr = pd.DataFrame(combined_drr, columns=['strain','passage','cross','deletion','recomb','respiration','mito_inst','nuc_inst', 'mean_ratio_dev']).reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ebd3ef4c-5548-4795-a990-7852313786ee",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# lines with changes in deletion status\n",
    "deletion_change = []\n",
    "for (s, cross), df in combined_drr.set_index('passage').loc[[1,35]].groupby(['strain','cross']):\n",
    "    if df.shape[0] == 2:\n",
    "        if df.loc[1, 'deletion'] == True and df.loc[35, 'deletion'] == False:\n",
    "            deletion_change.append([s, cross, 'gain'])\n",
    "        elif df.loc[1, 'deletion'] == False and df.loc[35, 'deletion'] == True:\n",
    "            deletion_change.append([s, cross, 'loss'])\n",
    "        else:\n",
    "            deletion_change.append([s, cross, 'no_change'])\n",
    "deletion_change = pd.DataFrame(deletion_change, columns=['strain','cross','change'])\n",
    "deletion_change['cross_order'] = deletion_change['cross'].apply(lambda x: cross_order[x])\n",
    "deletion_change['strain_order'] = deletion_change['strain'].apply(lambda x: int(x[1:]))\n",
    "#add filter for haplotype consistensy\n",
    "deletion_change['consistent'] = consistent_hap.set_index('strain').loc[deletion_change['strain'], 'consistent'].values"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb6d14bd-1b28-4f94-bba9-ec2f7874c4b9",
   "metadata": {},
   "source": [
    "## Fig S34"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c884cce-d58c-4038-a5e4-7ce3c3b3ab6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "ma_strains_sp_index = ma_strains.set_index('strain_passage')\n",
    "dc = deletion_change.loc[deletion_change['change'].isin(['gain', 'loss'])]\n",
    "Y_dict = dict(zip(dc.sort_values(by=['cross_order','strain_order'])['strain'], np.arange(0,dc.shape[0])*3))\n",
    "consistent_deletion = ['J15','J26','J29','J54','J64','L5','L46','B54','E34','E37','C87','F15']\n",
    "\n",
    "fig = plt.figure(figsize=[8,10])\n",
    "gs = plt.GridSpec(nrows=2, ncols=1, height_ratios=[14,1], hspace=0.08,\n",
    "                 left=0.06, right=0.91, top=0.99, bottom=0.05)\n",
    "xlim = (-500,ref_genome_length+500)\n",
    "\n",
    "ax = fig.add_subplot(gs[0])\n",
    "for i in ['right','top','left']:\n",
    "    ax.spines[i].set_visible(False)\n",
    "alpha = 0.3\n",
    "\n",
    "for (s, cross, change), df in dc.groupby(['strain', 'cross', 'change']):\n",
    "    sp1 = f'{s}_P1'\n",
    "    sp35 = f'{s}_P35'\n",
    "\n",
    "    for sp, off in zip([sp1, sp35], [0,1]):\n",
    "        S = ma_strains_sp_index.loc[sp, 'filename']\n",
    "        tracts = TRACTS.loc[TRACTS['strain']==S]\n",
    "    \n",
    "        y = Y_dict[s]+off\n",
    "        \n",
    "        for i in tracts.index:\n",
    "            (start, end, parent) = tracts.loc[i, ['start','end','parent']]\n",
    "            c = parents_color[parent.split('.')[-1]]\n",
    "            if start < end:\n",
    "                fa = FancyArrow(start, y, end-start, 0, width=0.8, head_length=0, head_width=0, color=c, lw=0, alpha=alpha)\n",
    "                ax.add_patch(fa)\n",
    "            elif start > end:\n",
    "                fa1 = FancyArrow(0, y, end, 0, width=0.8, head_length=0, head_width=0, color=c, lw=0, alpha=alpha)\n",
    "                fa2 = FancyArrow(start, y, ref_genome_length-start, 0, width=0.8, head_length=0, head_width=0, color=c, lw=0, alpha=alpha)\n",
    "                ax.add_patch(fa1)\n",
    "                ax.add_patch(fa2)\n",
    "        \n",
    "        ax.text(-700, y, sp.split('_')[1], ha='right', va='center', size=6)\n",
    "        if sp == sp1:\n",
    "            ax.text(-3e3, y+0.25, s, ha='right', va='center', size=8)\n",
    "        \n",
    "        #add support markers\n",
    "        markers = MARKERS[cross]\n",
    "        vcf_melt = VCF_MELT[cross]\n",
    "        vcf_melt = vcf_melt.loc[(vcf_melt['vma_uid'].isin(markers)) &\n",
    "                            (vcf_melt['higher']==True) &\n",
    "                            (vcf_melt['parent'].isin(parents_dict[cross])) &\n",
    "                            (vcf_melt['filename']==S)]\n",
    "        \n",
    "        for parent, df1 in vcf_melt.groupby('parent'):\n",
    "            c = parents_color[parent.split('.')[-1]]\n",
    "            ax.scatter(df1['POS'], np.repeat(y, df1.shape[0]), s=5, color=c)\n",
    "            \n",
    "    y = Y_dict[s]+0.5\n",
    "    ax.text(ref_genome_length+5e3, y, change, size=8, ha='left', va='center')\n",
    "    if s in consistent_deletion:\n",
    "        ax.text(ref_genome_length+750, y-0.35, '*', size=18, ha='left', va='center')\n",
    "    \n",
    "    if change == 'loss':\n",
    "        (y1, y2) = (y-0.5, y+0.5)\n",
    "    elif change == 'gain':\n",
    "        (y1, y2) = (y+0.5, y-0.5)\n",
    "    ax.scatter(ref_genome_length+3e3, y1, marker='s', color='k', edgecolor=(1,1,1,0), lw=1, s=24, clip_on=False)\n",
    "    ax.scatter(ref_genome_length+3e3, y2, marker='s', color='w', edgecolor='k', lw=1, s=24, clip_on=False)\n",
    "        \n",
    "        \n",
    "ax.set_xlim(xlim)\n",
    "ax.set_xticks(np.arange(0, 81e3, 1e4))\n",
    "ax.set_xticklabels(range(0,90,10))\n",
    "ax.text(ref_genome_length+3e3, -1, 'complete', rotation=90, ha='center', va='top')\n",
    "ax.set_yticks([])\n",
    "ax.set_ylim(-1, 105)\n",
    "\n",
    "# plot GFF entries\n",
    "ax = fig.add_subplot(gs[1])\n",
    "for i in ['left','right','top']:\n",
    "    ax.spines[i].set_visible(False)\n",
    "ax.arrow(0, 1, ref_genome_length, 0, color='0.9', lw=0, width=1, head_length=0, head_width=0, zorder=-1)\n",
    "\n",
    "legend_elms = []\n",
    "for at in annot_type_order:\n",
    "    if at != 'gc_cluster':\n",
    "        l = annot_type_alias[at]\n",
    "        fc = annot_type_color[at]\n",
    "        lw = 0\n",
    "        if fc == 'white':\n",
    "            lw = 1\n",
    "        legend_elms.append(Line2D([0], [0], color='w', marker='s', ms=9, mfc=fc, mec='black', mew=lw, label=l))\n",
    "ax.legend(handles=legend_elms, ncol=6, loc=9, bbox_to_anchor=(0.5, 1.1), frameon=False,\n",
    "         borderpad=0.0, labelspacing=0.2, handlelength=0.3, columnspacing=1.5)\n",
    "\n",
    "for i in artificial_genome_feat.loc[~artificial_genome_feat['annot_type'].isin(['gc_cluster','other'])].\\\n",
    "sort_values(by='annot_plot_order', ascending=False).index:\n",
    "    start, end, color, w, z = artificial_genome_feat.loc[i, [3,4,'annot_color','annot_width','annot_plot_order']]\n",
    "    ax.arrow(start, 1, end-start, 0, color=color, lw=0, width=w, head_length=0, head_width=0, zorder=z)\n",
    "ax.set_xlim(xlim)\n",
    "ax.set_ylim(0.45, 3)\n",
    "ax.set_xticks(np.arange(0, 81e3, 1e4))\n",
    "ax.set_xticklabels(range(0,90,10))\n",
    "ax.set_xlabel('kb')\n",
    "ax.set_yticks([])\n",
    "\n",
    "#plt.savefig('/home/mathieu/mhenault_landrylab/Publications/mito_ma/resubmission2_GRes/fig/deletion_change.svg', dpi=300)\n",
    "#plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89169efd-c4a5-4d34-8f4a-945fcafba8d8",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Fig S41"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b14318f4-be46-48e8-af15-9ce80983216d",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(nrows=2, figsize=[7,7],\n",
    "                        gridspec_kw=dict(hspace=0.3, left=0.15, bottom=0.07, right=0.96, top=0.93))\n",
    "\n",
    "ax = axes[0]\n",
    "\n",
    "dat = combined_drr.value_counts(['cross','passage','mito_inst']).rename('count').reset_index().pivot_table(index=['cross','passage'], columns='mito_inst', values='count').fillna(0).reset_index()\n",
    "dat['perc'] = (dat[True]/(dat[True]+dat[False])*100)\n",
    "dat['timepoint'] = dat['passage'].replace({1:'initial', 35:'final'})\n",
    "\n",
    "sns.barplot(x='cross', y='perc', hue='timepoint', palette={'initial':'0.8', 'final':'k'}, \n",
    "            order=cross_order, data=dat, ax=ax)\n",
    "\n",
    "for (cross, tp), df in dat.groupby(['cross','timepoint']):\n",
    "    x = cross_order[cross]\n",
    "    if tp == 'initial':\n",
    "        x -= 0.2\n",
    "    elif tp == 'final':\n",
    "        x += 0.2\n",
    "    \n",
    "    y, c = df[['perc', True]].iloc[0].values\n",
    "    if y > 0:\n",
    "        ax.text(x, y, f'{c:.0f}', ha='center', va='bottom', size=10)\n",
    "\n",
    "ax.set_ylabel('% lines with mtDNA instability')\n",
    "ax.set_xlabel('')\n",
    "ax.legend(loc=2, bbox_to_anchor=(0.1, 1), frameon=False, title='timepoint')\n",
    "\n",
    "ax = axes[1]\n",
    "mwu_mito_nuc_inst = []\n",
    "for cross, df in combined_drr.loc[(~combined_drr['cross'].isin(['BSc1','BSc2'])) &\n",
    "                                  ~(combined_drr['mean_ratio_dev']).isna()].groupby('cross'):\n",
    "\n",
    "    u = df.loc[df['mito_inst']==False, 'mean_ratio_dev']\n",
    "    v = df.loc[df['mito_inst']==True, 'mean_ratio_dev']\n",
    "    \n",
    "    if u.shape[0] > 0 and v.shape[0] > 0:\n",
    "        U, pval = stats.mannwhitneyu(u, v)\n",
    "        mwu_mito_nuc_inst.append([cross, U, pval])\n",
    "\n",
    "mwu_mito_nuc_inst = pd.DataFrame(mwu_mito_nuc_inst, columns=['cross', 'U', 'pval'])\n",
    "mwu_mito_nuc_inst['pval_corr'] = multipletests(mwu_mito_nuc_inst['pval'], method='fdr_bh')[1]\n",
    "mwu_mito_nuc_inst.set_index('cross', inplace=True)\n",
    "\n",
    "dat = combined_drr.copy().rename({'mito_inst':'mtDNA instability'})\n",
    "sns.violinplot(x='cross', y='mean_ratio_dev', hue='mito_inst', order=['CC1','CC2','CC3','BB1','BB2','BC1','BC2','BA1','BA2'],\n",
    "               palette={False:'white', True:'grey'}, scale='width', cut=0, data=dat, ax=ax)\n",
    "for cross in mwu_mito_nuc_inst.loc[mwu_mito_nuc_inst['pval_corr']<=0.05].index:\n",
    "    x = cross_order[cross]\n",
    "    ax.plot([x-0.3, x+0.3], np.repeat(0.14, 2), color='k')\n",
    "    ax.text(x, 0.14, plot_pval_symbol(mwu_mito_nuc_inst.loc[cross, 'pval_corr']), va='bottom', ha='center')\n",
    "\n",
    "ax.set_ylabel('mean coverage depth deviation')\n",
    "ax.set_ylim(0, 0.155)\n",
    "ax.set_xlabel('')\n",
    "ax.legend(loc=2, bbox_to_anchor=(0.1, 1), frameon=False, title='mtDNA instability')\n",
    "    \n",
    "fig.text(0.02, 0.94, 'A', size=24, weight='bold')\n",
    "fig.text(0.02, 0.47, 'B', size=24, weight='bold')\n",
    "    \n",
    "sns.despine()\n",
    "\n",
    "#plt.savefig('/home/mathieu/mhenault_landrylab/Publications/mito_ma/resubmission2_GRes/fig/mito_nuc_instability.svg', dpi=300)\n",
    "#plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfcd918a-a148-4ddf-91ee-d54123cc3f99",
   "metadata": {},
   "source": [
    "## Fisher exact tests for pairwise combinations of variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11d72ef6-8720-40de-95b1-ddf1264cc25c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "fe_combined = []\n",
    "for v1, v2 in itertools.combinations(['deletion','recomb','respiration','mito_inst','nuc_inst'], 2):\n",
    "    name = f'{v1}*{v2}'\n",
    "    for (cross, p), df in combined_drr.groupby(['cross','passage']):\n",
    "        F = df.value_counts([v1,v2]).rename('count').reset_index().pivot_table(index=v1, columns=v2, values='count', aggfunc=lambda x: x)\n",
    "        \n",
    "        if F.shape == (2,2):\n",
    "            odds, pval = stats.fisher_exact(F.fillna(1))\n",
    "            fe_combined.append([cross, p, name, odds, pval])\n",
    "        else:\n",
    "            fe_combined.append([cross, p, name, np.nan, np.nan])\n",
    "\n",
    "fe_combined = pd.DataFrame(fe_combined, columns=['cross','passage','test','odds_ratio','pval'])\n",
    "\n",
    "fe_combined.loc[~fe_combined['pval'].isna(), 'pval_corr'] = multipletests(fe_combined.loc[~fe_combined['pval'].isna(), 'pval'], method='fdr_bh')[1]\n",
    "fe_combined['log_pval'] = -1*np.log10(fe_combined['pval_corr'])\n",
    "fe_combined['log_or'] = np.log10(fe_combined['odds_ratio'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f555bc4a-15e8-4cd5-a559-a7cde9bd2663",
   "metadata": {},
   "outputs": [],
   "source": [
    "var_alias = {'deletion':'mtDNA\\ndeletion','respiration':'respiration','recomb':'mtDNA\\nrecombination','mito_inst':'mtDNA\\ninstability','nuc_inst':'aneuploidy\\ninstability'}\n",
    "var_alias_short = {'deletion':'mtDNA del','respiration':'resp','recomb':'mtDNA rec','mito_inst':'mtDNA inst','nuc_inst':'aneup inst'}\n",
    "var_order_dict = {j:i for i,j in enumerate(['deletion','recomb','respiration','mito_inst','nuc_inst'])}\n",
    "test_order = ['deletion*recomb',\n",
    "              'deletion*respiration',\n",
    "              'deletion*mito_inst',\n",
    "              'deletion*nuc_inst',\n",
    "              'recomb*respiration',\n",
    "             'recomb*mito_inst',\n",
    "             'recomb*nuc_inst',\n",
    "             'respiration*mito_inst',\n",
    "             'respiration*nuc_inst',\n",
    "             'mito_inst*nuc_inst']\n",
    "test_order_dict = {j:i for i,j in enumerate(test_order)}\n",
    "cmap_test = {j:i for i,j in enumerate([t for t in test_order if t in fe_combined.loc[fe_combined['pval_corr']<=0.05, 'test'].values])}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef6f4817-e44d-4687-a0d3-9317d011549e",
   "metadata": {},
   "source": [
    "## Fig 6AC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "90c90ae5-c30e-4321-a60f-35064db21c8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "for p, p_alias in zip([1, 35], ['initial timepoint', 'final timepoint']):\n",
    "    \n",
    "    fig= plt.figure(figsize=[4,5])\n",
    "    gs = plt.GridSpec(ncols=1, nrows=2, height_ratios=[3,2], hspace=0.1, left=0.3, right=0.77, top=0.94, bottom=0.08)\n",
    "    \n",
    "    dat = fe_combined.loc[fe_combined['passage']==p].pivot_table(index='cross', columns='test', values='log_or', dropna=False)\n",
    "\n",
    "    ax = fig.add_subplot(gs[0])\n",
    "    cbar_ax = fig.add_axes([0.81, 0.5, 0.03, 0.25])\n",
    "    sns.heatmap(dat.loc[cross_order, test_order], cmap='BrBG', ax=ax, center=0, vmin=-2.6, vmax=2.6, # center=-1*np.log10(0.05), vmax=9,\n",
    "               cbar_ax=cbar_ax, cbar_kws=dict(label='log$_{10}$ odds ratio'))\n",
    "\n",
    "    for (test,x), (cross, y) in itertools.product(zip(test_order, range(10)), cross_order.items()):\n",
    "        pval, odds = fe_combined.set_index(['passage','cross','test']).loc[(p, cross, test), ['pval_corr','log_or']]\n",
    "        if abs(odds) >= 1.5:\n",
    "            c = 'white'\n",
    "        else:\n",
    "            c = 'black'\n",
    "        ax.text(x+0.5, y+0.5, plot_pval_symbol(pval), color=c, ha='center', va='center')\n",
    "\n",
    "    \n",
    "    ax.set_xticklabels([])\n",
    "    ax.set_xlabel('')\n",
    "    ax.set_yticklabels(cross_order, rotation=0)\n",
    "    ax.set_ylabel('')\n",
    "    ax.set_title(p_alias, size=14)\n",
    "    \n",
    "    for s in ['top', 'bottom', 'right', 'left']:\n",
    "        ax.spines[s].set_visible(True)\n",
    "        \n",
    "    #plot variables\n",
    "    ax = fig.add_subplot(gs[1])    \n",
    "\n",
    "    for i,j in itertools.product(range(11), range(5)):\n",
    "        ax.scatter(i-0.5, j, marker='o', s=8**2, c='white', edgecolors='0.6', zorder=0)\n",
    "    for t in test_order:\n",
    "        v1, v2 = t.split('*')\n",
    "\n",
    "        ax.plot(np.repeat(test_order_dict[t], 2)+0.5, [var_order_dict[v] for v in (v1, v2)], c='k', lw=2,\n",
    "                marker='o', ms=8, mfc='white', mec='black', mew=2, zorder=1)\n",
    "    \n",
    "    ax.set_xticks([])\n",
    "    ax.set_xlim(0, 10)\n",
    "    ax.set_yticks(range(5))\n",
    "    ax.set_yticklabels([var_alias[v] for v in var_order_dict])\n",
    "    ax.invert_yaxis()\n",
    "    for s in ['top', 'bottom', 'right']:\n",
    "        ax.spines[s].set_visible(False)\n",
    "        \n",
    "    if p == 1:\n",
    "        fig.text(0.03, 0.94, 'A', size=24, fontweight='bold')\n",
    "        fig.text(0.93, 0.94, 'B', size=24, fontweight='bold')\n",
    "    elif p == 35:\n",
    "        fig.text(0.03, 0.94, 'C', size=24, fontweight='bold')\n",
    "        fig.text(0.93, 0.94, 'D', size=24, fontweight='bold')\n",
    "    \n",
    "    \n",
    "    #plt.savefig(f'/home/mathieu/mhenault_landrylab/Publications/mito_ma/resubmission2_GRes/fig/Fig6A_P{p:.0f}.svg', dpi=300)\n",
    "    #plt.show()\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6064d9c-b942-458d-90c0-84531b971f06",
   "metadata": {},
   "source": [
    "## Fig 6BD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d87335a5-2f2f-4334-85a8-4086026b6d3c",
   "metadata": {},
   "outputs": [],
   "source": [
    "for p in [1, 35]:\n",
    "    \n",
    "    \n",
    "    fig= plt.figure(figsize=[3,5])\n",
    "    gs = plt.GridSpec(ncols=3, nrows=5, hspace=1.7, wspace=1.7, left=0.15, right=0.93, top=0.94, bottom=0.09)\n",
    "\n",
    "    Dat = fe_combined.loc[(fe_combined['passage']==p) & (fe_combined['pval_corr']<=0.05)].copy()\n",
    "    Dat['cross_order'] = Dat['cross'].apply(lambda x: cross_order[x])\n",
    "    Dat['v1'] = Dat['test'].apply(lambda x: x.split('*')[0])\n",
    "    Dat['v1_order'] = Dat['v1'].apply(lambda x: var_order_dict[x])\n",
    "    Dat['v2'] = Dat['test'].apply(lambda x: x.split('*')[1])\n",
    "    Dat['v2_order'] = Dat['v2'].apply(lambda x: var_order_dict[x])\n",
    "    Dat = Dat.sort_values(by=['v1_order','v2_order','cross_order']).reset_index(drop=True)\n",
    "    \n",
    "    if p == 1:\n",
    "        Dat = pd.concat([Dat, fe_combined.loc[[56,58,60,40,42,31]]])\n",
    "    if p == 35:\n",
    "        Dat = pd.concat([Dat, fe_combined.loc[[61,41,43]]])\n",
    "    Dat['v1'] = Dat['test'].apply(lambda x: x.split('*')[0])\n",
    "    Dat['v2'] = Dat['test'].apply(lambda x: x.split('*')[1])\n",
    "    \n",
    "    for i, (ax_row, ax_col) in zip(Dat.index, itertools.product(range(6), range(3))):\n",
    "        test, v1, v2, cross = Dat.loc[i, ['test','v1','v2','cross']]\n",
    "\n",
    "        ax = fig.add_subplot(gs[(ax_row, ax_col)])\n",
    "\n",
    "        dat = combined_drr.loc[(combined_drr['cross']==cross) & (combined_drr['passage']==p)].value_counts([v1, v2]).rename('count').reset_index()\n",
    "        dat[v1] = dat[v1].replace({True:'T', False:'F'})\n",
    "        dat[v2] = dat[v2].replace({True:'T', False:'F'})\n",
    "        dat = dat.pivot_table(index=v1, columns=v2, values='count', aggfunc=lambda x: x).fillna(0)\n",
    "        for b in ['T','F']:\n",
    "            if b not in dat.columns:\n",
    "                dat[b] = 0\n",
    "            if b not in dat.index:\n",
    "                dat.loc[b] = 0\n",
    "\n",
    "        cmap = LinearSegmentedColormap.from_list('custom', ['white', sns.color_palette()[cmap_test[test]]], N=256)\n",
    "        sns.heatmap(dat.loc[['F','T'], ['T','F']], cmap=cmap, annot=True, annot_kws={'size':9}, fmt='.0f', cbar=False, ax=ax, vmin=0,\n",
    "                   linewidths=0.5, linecolor='k')\n",
    "\n",
    "        ax.set_title(cross, size=10, fontweight='bold')\n",
    "        ax.set_xticks([0.5, 1.5])\n",
    "        ax.set_yticks([0.5, 1.5])\n",
    "        ax.set_xticklabels(['T','F'], size=9, rotation=0)\n",
    "        ax.set_yticklabels(['F','T'], size=9, rotation=0)\n",
    "\n",
    "        ax.set_ylabel(var_alias_short[v1], size=9, labelpad=1)\n",
    "        ax.set_xlabel(var_alias_short[v2], size=9, labelpad=1)\n",
    "        \n",
    "    if p == 1:\n",
    "        R = [Rectangle((0.03, 0.01), 0.94, 0.39, fc='0.85', lw=0, transform=fig.transFigure, zorder=-1)]\n",
    "        \n",
    "    if p == 35:\n",
    "        R = [Rectangle((0.03, 0.01), 0.94, 0.195, fc='0.85', lw=0, transform=fig.transFigure, zorder=-1)]\n",
    "    fig.patches.extend(R)\n",
    "\n",
    "    #plt.savefig(f'/home/mathieu/mhenault_landrylab/Publications/mito_ma/resubmission2_GRes/fig/Fig6B_P{p:.0f}.svg', dpi=300)\n",
    "    #plt.show()\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9d4643e-29a0-4846-8a1e-be732f12a273",
   "metadata": {},
   "source": [
    "## Combine growth data with haplotype categories (parental, rec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "edce1dad-0872-401f-b49d-34c300fb928e",
   "metadata": {},
   "outputs": [],
   "source": [
    "gdrec = []\n",
    "for cross, df in ma_strains.loc[ma_strains['identity_filter']].groupby('cross'):\n",
    "    if cross in cross_order:\n",
    "        for fn in df['filename'].values:\n",
    "            \n",
    "            sp = fn.split('.')[-1]\n",
    "            s, p = sp.split('_')\n",
    "            p = int(p.strip('P'))\n",
    "            fnr = fn\n",
    "            \n",
    "            # correct fn for clones\n",
    "            if ma_strains.loc[fn, 'mt_haplotype'] == 'clone':\n",
    "                fn_list = ma_strains.loc[(ma_strains['strain']==s) & (ma_strains['mt_haplotype']!='clone'), 'filename']\n",
    "                if fn_list.shape[0] == 1:\n",
    "                    fnr = fn_list.iloc[0]\n",
    "                elif fn == 'HI.4802.001.N708---N506.B40_P1':\n",
    "                    fnr = 'NS.1250.002.N704---N507.B40_P35'\n",
    "                elif fn == 'NS.1249.002.N712---N504.B55_P10':\n",
    "                    fnr = 'NS.1250.002.N705---N508.B55_P35'\n",
    "     \n",
    "            deletion = np.nan\n",
    "            recomb = np.nan\n",
    "            parent = np.nan\n",
    "            ypd_25 = np.nan\n",
    "            ypd_37 = np.nan\n",
    "            ypeg_25 = np.nan\n",
    "            ypeg_37 = np.nan\n",
    "            resp = np.nan\n",
    "            fid = np.nan\n",
    "            \n",
    "            # deletion\n",
    "            if fn in STRAIN_ORDER_DELETION[cross][True]:\n",
    "                deletion = False\n",
    "            elif False in STRAIN_ORDER_DELETION[cross]:\n",
    "                if fn in STRAIN_ORDER_DELETION[cross][False]:\n",
    "                    deletion = True\n",
    "            \n",
    "            # recomb\n",
    "            if fnr in REC['strain'].values:\n",
    "                if REC.set_index('strain').loc[fnr, 'count'] > 0:\n",
    "                    recomb = True\n",
    "                else:\n",
    "                    recomb = False\n",
    "            #major parent\n",
    "            if recomb == False:\n",
    "                parent = TRACTS.set_index('strain').loc[fnr, 'parent'].split('.')[-1]\n",
    "            elif recomb == True:\n",
    "                parent = 'rec'\n",
    "            \n",
    "            #respiration\n",
    "            if sp in GDR.index:\n",
    "                ypd_25, ypd_37, ypeg_25, ypeg_37, resp, fid = GDR.loc[sp, ['YPD_25','YPD_37','YPEG_25','YPEG_37','resp','identity_filter']]\n",
    "                \n",
    "            gdrec.append([fn, cross, s, p, deletion, recomb, parent, ypd_25, ypd_37, ypeg_25, ypeg_37, resp, fid])\n",
    "\n",
    "gdrec = pd.DataFrame(gdrec, columns=['filename','cross','strain','passage','deletion','recomb','parent','YPD_25','YPD_37','YPEG_25','YPEG_37','resp','identity_filter'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6f0cd0c-2791-46dc-b162-0f85f7eb7cb8",
   "metadata": {},
   "source": [
    "## Mann-Whitney U tests between categories of haplotypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db9af8fc-742c-4c5a-8b00-4c1ea36cbbcc",
   "metadata": {},
   "outputs": [],
   "source": [
    "mwu_growth_rec = []\n",
    "for cross, df in gdrec.loc[gdrec['resp']==True].groupby(['cross']):\n",
    "    for cond in cond_order:\n",
    "        df1 = df.loc[(~df[cond].isna()) & (~df['parent'].isna())]\n",
    "        p1, p2 = [p.split('.')[-1] for p in parents_dict[cross]]\n",
    "        order = [p1, 'rec', p2]\n",
    "        order = [p for p in order if p in df1['parent'].values]\n",
    "        for p1, p2 in itertools.combinations(order, 2):\n",
    "            u = df1.loc[df1['parent']==p1, cond]\n",
    "            v = df1.loc[df1['parent']==p2, cond]\n",
    "            U, pval = stats.mannwhitneyu(u,v)\n",
    "            diff = u.median()-v.median()\n",
    "            mwu_growth_rec.append([cross, cond, p1, p2, U, pval, diff])\n",
    "mwu_growth_rec = pd.DataFrame(mwu_growth_rec, columns=['cross','cond','p1','p2','U','pval','diff'])\n",
    "mwu_growth_rec.loc[~mwu_growth_rec['pval'].isna(), 'pval_corr'] = \\\n",
    "multipletests(mwu_growth_rec.loc[~mwu_growth_rec['pval'].isna(), 'pval'], method='fdr_bh')[1]\n",
    "mwu_growth_rec['log_pval_corr'] = mwu_growth_rec['pval_corr'].apply(lambda x: -1*np.log10(x))\n",
    "mwu_growth_rec['diff_abs'] = mwu_growth_rec['diff'].abs()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c13f2d4c-ebf3-4909-bb55-4a1567320b41",
   "metadata": {},
   "source": [
    "## Fig S35"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a3414c8-1f35-435b-8a2e-833b13745ff9",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(ncols=4, nrows=3, \n",
    "                         figsize=[9,9], gridspec_kw=dict(top=0.97, right=0.97, bottom=0.08, left=0.06,\n",
    "                                                          hspace=0.5, wspace=0.25))\n",
    "parents_color_rec = parents_color\n",
    "parents_color_rec['rec'] = 'white'\n",
    "cross_ax_dict = dict(zip(cross_order, itertools.product(range(3), range(4))))\n",
    "\n",
    "for cross, df in gdrec.loc[gdrec['resp']==True].groupby('cross'):\n",
    "    \n",
    "    p1, p2 = [p.split('.')[-1] for p in parents_dict[cross]]\n",
    "    order = [p1, 'rec', p2]\n",
    "    order = [p for p in order if p in df['parent'].values]\n",
    "    c = [parents_color_rec[x] for x in order]\n",
    "    df = pd.melt(df, id_vars=['cross', 'parent'], value_vars=cond_order, var_name='cond', value_name='AUC')\n",
    "    y_max = df.groupby('cond')['AUC'].max().to_dict()\n",
    "    \n",
    "    ax_idx = cross_ax_dict[cross]\n",
    "    ax = axes[ax_idx]\n",
    "    \n",
    "    sns.violinplot(x='cond', y='AUC', hue='parent', data=df, scale='width', cut=0, ax=ax,\n",
    "                   order=cond_order, hue_order=order, palette=c, linewidth=1)\n",
    "    ax.legend_.remove()\n",
    "    \n",
    "    ax.text(0.5, 1, cross, transform=ax.transAxes, size=14, ha='center')\n",
    "    if ax_idx[1] != 0:\n",
    "        ax.set_ylabel('')\n",
    "    ax.set_xlabel('')\n",
    "    ax.set_xticklabels([cond_alias[c] for c in cond_order], rotation=30, ha='right')\n",
    "    \n",
    "    ax.set_ylim(15,40)\n",
    "    legend_elms = [Line2D([0], [0], color='w', marker='s', mfc=parents_color_rec[x], \n",
    "                          ms=9, mec='k', mew=1, label=x) for x in order]\n",
    "    ax.legend(handles=legend_elms, loc=3, bbox_to_anchor=[0,-0.02], \n",
    "             handlelength=0.3, labelspacing=0.3, borderaxespad=0.2)\n",
    "    \n",
    "    for i, cond in enumerate(cond_order):\n",
    "        df1 = mwu_growth_rec.loc[(mwu_growth_rec['cross']==cross) & (mwu_growth_rec['cond']==cond)].set_index(['p1','p2'])\n",
    "        \n",
    "        offset_y = y_max[cond] + 2\n",
    "        for (p1, x1), (p2, x2) in itertools.combinations(zip(order, range(len(order))), 2):\n",
    "            p = plot_pval_symbol(df1.loc[(p1, p2), 'pval_corr'])\n",
    "            if p != None:\n",
    "                X = np.array([x1, x2])\n",
    "                X = (X-np.mean(X))*0.5+i\n",
    "                ax.plot(X, np.repeat(offset_y, 2), lw=1, color='k', clip_on=False)\n",
    "                ax.text(np.mean(X), offset_y, p, ha='center', size=10)\n",
    "                offset_y += 3\n",
    "                \n",
    "ax = axes[2,3]\n",
    "ax.axis('off')\n",
    "    \n",
    "sns.despine()\n",
    "#plt.savefig('/home/mathieu/mhenault_landrylab/Publications/mito_ma/resubmission2_GRes/fig/fitness_mt_hap.svg', dpi=300)\n",
    "#plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b8a26fd-3bfe-4983-901f-168b316d6805",
   "metadata": {},
   "source": [
    "## Fig S36"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "318a164d-2f20-4abe-b8f1-357a01471d23",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(figsize=[6,4], gridspec_kw=dict(right=0.75, left=0.1, top=0.96, bottom=0.14))\n",
    "dat = mwu_growth_rec.copy()\n",
    "dat['condition'] = dat['cond'].apply(lambda x: cond_alias[x])\n",
    "sns.scatterplot(x='diff_abs', y='log_pval_corr', hue='cross', hue_order=cross_order, \n",
    "                palette=cross_color, style='condition', data=dat, ax=ax)\n",
    "ax.set_ylim(-0.03, 0.7)\n",
    "ax.set_xlim(-0.03, 1.5)\n",
    "ax.legend(loc=2, bbox_to_anchor=(1,1), ncol=1, frameon=False)\n",
    "ax.margins(0.1)\n",
    "\n",
    "ax.set_xlabel('median growth difference')\n",
    "ax.set_ylabel('-log$_{10}$ FDR-corrected p-value')\n",
    "sns.despine(ax=ax)\n",
    "\n",
    "ax = fig.add_axes([0.2, 0.6, 0.25 ,0.3])\n",
    "sns.scatterplot(x='diff_abs', y='log_pval_corr', hue='cross', hue_order=cross_order, \n",
    "                palette=cross_color, style='condition', data=dat, ax=ax, legend=False)\n",
    "ax.margins(0.1)\n",
    "ax.set_xlabel('')\n",
    "ax.set_ylabel('')\n",
    "\n",
    "#plt.savefig('/home/mathieu/mhenault_landrylab/Publications/mito_ma/resubmission2_GRes/fig/growth_diff_effect_size.svg', dpi=300)\n",
    "#plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43933763-fbd3-432f-bc04-a21963e49d86",
   "metadata": {},
   "source": [
    "## Table S2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "98a797b7-fe65-4c80-b257-c5eea47941f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "ma_strains_export = ma_strains.loc[ma_strains['mt_haplotype']!='none'].copy().reset_index(drop=True)\n",
    "cdrr_idx = combined_drr.set_index(['strain','passage']).sort_index()\n",
    "\n",
    "for (s,p,clone), df in ma_strains_export.groupby(['strain','passage','mt_haplotype']):\n",
    "    if (s,p) in cdrr_idx.index:\n",
    "\n",
    "        ma_strains_export.loc[df.index, 'respiration'] = cdrr_idx.loc[(s,p), 'respiration'].iloc[0]\n",
    "        #if clone != 'clone':\n",
    "        ma_strains_export.loc[df.index, 'recomb'] = cdrr_idx.loc[(s,p), 'recomb'].iloc[0]\n",
    "        ma_strains_export.loc[df.index, 'deletion'] = cdrr_idx.loc[(s,p), 'deletion'].iloc[0]\n",
    "        ma_strains_export.loc[df.index, 'mito_inst'] = cdrr_idx.loc[(s,p), 'mito_inst'].iloc[0]\n",
    "        ma_strains_export.loc[df.index, 'nuc_inst'] = cdrr_idx.loc[(s,p), 'nuc_inst'].iloc[0]\n",
    "\n",
    "ma_strains_export['cross_order'] = ma_strains_export['cross'].apply(lambda x: cross_order[x])\n",
    "ma_strains_export['strain_num'] = ma_strains_export['strain'].apply(lambda x: int(x[1:]))\n",
    "\n",
    "for p, df in ma_strains_export.groupby('passage'):\n",
    "    if p == 1:\n",
    "        ma_strains_export.loc[df.index, 'timepoint'] = 'initial'\n",
    "    elif p == 35:\n",
    "        ma_strains_export.loc[df.index, 'timepoint'] = 'final'\n",
    "\n",
    "ma_strains_export = ma_strains_export.sort_values(by=['cross_order','strain_num','passage']).replace({True:'True', False:'False'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d2e5c4b-1313-4a4b-a9a0-8b6646dacec2",
   "metadata": {},
   "outputs": [],
   "source": [
    "#export for S2\n",
    "#ma_strains_export[['cross','strain','passage','timepoint','filename','mt_haplotype','recomb','respiration','deletion','mito_inst','nuc_inst']]\\\n",
    "#.to_csv('/home/mathieu/mhenault_landrylab/Publications/mito_ma/resubmission2_GRes/Supplemental_Table_S2.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6696e20-3df0-4b9c-946d-5b38a07def49",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Mobility of introns in COB and COX1\n",
    "## Identify introns to check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c32ab4a1-30bf-48eb-8735-6556decf64a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "agfi = artificial_genome_feat.set_index('Name')\n",
    "\n",
    "introns_to_check = []\n",
    "for cross in cross_order:\n",
    "\n",
    "    p1, p2 = [p.split('.')[-1] for p in parents_dict[cross]]\n",
    "    gff = GFF.loc[GFF['strain'].isin([p1,p2])]\n",
    "    vcf_melt = VCF_MELT[cross]\n",
    "    markers = MARKERS[cross]\n",
    "    vcf_melt = vcf_melt.loc[(vcf_melt['marker']==True) &\n",
    "                            (vcf_melt['vma_uid'].isin(markers))]\n",
    "    marker_pos = vcf_melt.groupby('vma_uid').apply(lambda x: x['POS'].iloc[0])\n",
    "\n",
    "    for intron, df in gff.loc[(gff['annot_type']=='intron') & \n",
    "                         (gff['Name']!='ai2')].groupby('Name'):\n",
    "\n",
    "        absent = np.nan\n",
    "        for p in (p1, p2):\n",
    "            if p not in df['strain'].values:\n",
    "                absent = p\n",
    "            \n",
    "        if not pd.isna(absent):\n",
    "            check_mb = [False, False]\n",
    "            bp1, bp2 = agfi.loc[intron, [3,4]].astype(int)\n",
    "\n",
    "            #define adjacent markers\n",
    "            mb1 = marker_pos.loc[marker_pos<bp1]\n",
    "            mb2 = marker_pos.loc[marker_pos>bp2]\n",
    "            if mb1.shape[0] > 0 and mb2.shape[0] > 0:\n",
    "                mb1 = (mb1-bp1).sort_values().index[-1]\n",
    "                mb2 = (mb2-bp2).sort_values().index[0]\n",
    "\n",
    "                for bi, mb in enumerate([mb1, mb2]):\n",
    "                    annot_mb = gft[marker_pos[mb]]\n",
    "\n",
    "                    at, name = artificial_genome_feat.loc[[i[2] for i in list(annot_mb)]].sort_values(by='annot_plot_order').iloc[-1][['annot_type', 'Name']]\n",
    "                    #if at in ['exon','rna_exon','gene','rna', 'other', 'gc_cluster']:\n",
    "                    if at not in ['intron', 'orf']:\n",
    "                        check_mb[bi] = True\n",
    "                    else:\n",
    "                        if set(gff.loc[gff['Name']==name, 'strain']) == set([p1, p2]):\n",
    "                            check_mb[bi] = True\n",
    "\n",
    "                introns_to_check.append([cross, intron, bp1, bp2, mb1, mb2, absent, all(check_mb)])\n",
    "introns_to_check = pd.DataFrame(introns_to_check, columns=['cross', 'intron', 'bp1', 'bp2', 'mb1', 'mb2', 'absent', 'check'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6cfc452-aa52-4e39-b4f4-1402423f85e2",
   "metadata": {},
   "source": [
    "## Extract coverage depth profiles around intron-exon junctions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3aa93968-c45b-4f71-aa12-b7d4d79d0fd6",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "wdw = 50\n",
    "intron_profiles = []\n",
    "for cross, df in introns_to_check.loc[introns_to_check['check']==True].groupby('cross'):\n",
    "    \n",
    "    p1, p2 = parents_dict[cross]\n",
    "    P1, P2 = [p.split('.')[-1] for p in (p1, p2)]\n",
    "    \n",
    "    #gff = GFF.loc[GFF['strain'].isin([P1,P2])]\n",
    "    vcf_melt = VCF_MELT[cross]\n",
    "    vcf_melt = vcf_melt.loc[vcf_melt['marker']].set_index(['filename','vma_uid'])\n",
    "    \n",
    "    S = ma_strains.loc[(ma_strains['cross']==cross) & (ma_strains['mthap_filter']), 'filename']\n",
    "    \n",
    "    for i in df.index:\n",
    "        intron, bp1, bp2, mb1, mb2, absent = introns_to_check.loc[i, ['intron', 'bp1', 'bp2', 'mb1', 'mb2', 'absent']].values\n",
    "\n",
    "        for (bp, mb) in [(bp1, mb1), (bp2, mb2)]:\n",
    "            \n",
    "            window = range(bp-wdw, bp+wdw)\n",
    "            parental_profiles = {}\n",
    "            pp_check = True\n",
    "            for p in parents_dict[cross]:\n",
    "                depth = DEPTH[p].set_index('pos')\n",
    "                pprofile = depth.loc[window, 'depth']\n",
    "\n",
    "                pprofile = pprofile/np.quantile(pprofile, 0.8)\n",
    "                if pprofile.isna().sum() != 0:\n",
    "                    pp_check = False\n",
    "                parental_profiles[p] = pprofile\n",
    "            \n",
    "            if pp_check == True:\n",
    "            \n",
    "                for s in S:\n",
    "\n",
    "                    # get parent of adjacent marker\n",
    "                    pmb = np.nan\n",
    "                    if (s,mb) in vcf_melt.index:\n",
    "                        pmb = vcf_melt.loc[(s,mb), 'parent']\n",
    "\n",
    "                    #analyze profiles\n",
    "                    depth = DEPTH[s]\n",
    "                    profile = depth.loc[window, 'depth']\n",
    "                    #profile = profile/profile.mean()\n",
    "                    profile = profile/np.quantile(profile, 0.8)\n",
    "                    if profile.isna().sum() == 0:\n",
    "                        profile_r = {}\n",
    "                        profile_d = {}\n",
    "                        for p, pprofile in parental_profiles.items():\n",
    "                            r, pval = stats.pearsonr(profile, pprofile)\n",
    "                            profile_r[p] = r\n",
    "                            d = euclidean(profile, pprofile)\n",
    "                            profile_d[p] = d\n",
    "\n",
    "                        intron_profiles.append([cross, intron, s, bp, mb, pmb, profile_r[p1], profile_r[p2], profile_d[p1], profile_d[p2]])\n",
    "\n",
    "intron_profiles = pd.DataFrame(intron_profiles, columns=['cross', 'intron', 'filename', 'bp', 'mb', 'pmb', 'pearsonr_p1', 'pearsonr_p2', 'euclid_p1', 'euclid_p2'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16e11e26-3be4-4d70-a877-7ce983d3d991",
   "metadata": {},
   "outputs": [],
   "source": [
    "#make calls based on pearson correlations and euclidean distance\n",
    "intron_profiles['call'] = np.nan\n",
    "for cross, df in intron_profiles.groupby('cross'):\n",
    "    p1, p2 = parents_dict[cross]\n",
    "    df.loc[(df['pearsonr_p1']>df['pearsonr_p2']) & (df['euclid_p1']<df['euclid_p2']), 'call'] = p1\n",
    "    df.loc[(df['pearsonr_p2']>df['pearsonr_p1']) & (df['euclid_p2']<df['euclid_p1']), 'call'] = p2\n",
    "    intron_profiles.loc[df.index, 'call'] = df['call']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "46526572-97fc-40c1-a781-035a2eac7236",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#classify introns which have all information\n",
    "intron_profiles['both_sides'] = False\n",
    "for (intron, s), df in intron_profiles.loc[(~intron_profiles['call'].isna()) &\n",
    "                                           (~intron_profiles['pmb'].isna())].groupby(['intron','filename']):\n",
    "    if df.shape[0] == 2:\n",
    "        intron_profiles.loc[df.index, 'both_sides'] = True"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea5697de-e033-4525-8ac3-f82746b75b19",
   "metadata": {},
   "source": [
    "## Call introns based on junction calls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7be22cf5-e5dc-469d-b24b-3f828a9e7b15",
   "metadata": {},
   "outputs": [],
   "source": [
    "intron_calls = []\n",
    "\n",
    "for (cross, intron, s), df in intron_profiles.loc[intron_profiles['both_sides']].sort_values(by='bp').groupby(['cross','intron','filename']):\n",
    "    pmb1, pmb2 = df['pmb']\n",
    "    call1, call2 = df['call']\n",
    "    bp1, bp2 = df['bp']\n",
    "    absent = introns_to_check.set_index(['cross','intron']).loc[(cross,intron), 'absent']\n",
    "    \n",
    "    rec_bp = np.nan\n",
    "    rec_bp_side = np.nan\n",
    "    rec_pmb = np.nan\n",
    "    \n",
    "    if call1 == call2:\n",
    "        if pmb1 == pmb2:\n",
    "            if pmb1 == call1:\n",
    "                c = 'wt'\n",
    "            if pmb1 != call1:\n",
    "                if call1.split('.')[-1] == absent:\n",
    "                    c = 'excision'\n",
    "                elif call1.split('.')[-1] != absent:\n",
    "                    c = 'mobility'\n",
    "        else:\n",
    "            if call1.split('.')[-1] == absent:\n",
    "                c = 'rec'\n",
    "            elif call1.split('.')[-1] != absent:\n",
    "                c = 'rec_intron'\n",
    "                if call1 == pmb1:\n",
    "                    rec_bp = bp2\n",
    "                    rec_pmb = pmb2\n",
    "                    rec_bp_side = 'right'\n",
    "                elif call2 == pmb2:\n",
    "                    rec_bp = bp1\n",
    "                    rec_pmb = pmb1\n",
    "                    rec_bp_side = 'left'\n",
    "\n",
    "    else:\n",
    "        c = 'call_inconsistent'\n",
    "    \n",
    "    intron_calls.append([cross, intron, s, pmb1, pmb2, call1, call2, c, rec_bp, rec_pmb, rec_bp_side])\n",
    "    \n",
    "intron_calls = pd.DataFrame(intron_calls, columns=['cross', 'intron', 'filename', 'pmb1', 'pmb2', 'call1', 'call2', 'class', 'rec_bp', 'rec_pmb', 'rec_bp_side'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11ef0789-ca64-4f68-a8f4-abe49bffe437",
   "metadata": {},
   "outputs": [],
   "source": [
    "# intron polymorphisms consistent with rec tracts, after visual examination\n",
    "intron_call_rec_consistent = [['HI.4803.001.N706---N504.I11_P35', 'bi2'],\n",
    "                              ['HI.4803.001.N706---N504.I11_P35', 'ai1'],\n",
    "                              ['HI.4803.001.N709---N503.I47_P35', 'ai1'],\n",
    "                              ['HI.4803.001.N711---N506.I33_P35', 'bi2'],\n",
    "                              ['HI.4803.002.N701---N504.I38_P35', 'ai1'],\n",
    "                              ['HI.4803.002.N707---N505.I23_P35', 'ai1'],\n",
    "                              ['HI.4803.002.N707---N517.I40_P35', 'ai1'],\n",
    "                              ['HI.4803.002.N702---N517.H46_P35', 'ai1'],\n",
    "                              ['HI.4803.002.N706---N507.A87_P35', 'bi3'],\n",
    "                              ['HI.4803.002.N711---N505.A3_P35', 'bi3'],\n",
    "                              ['HI.4803.002.N703---N504.A70_P35', 'bi3'],\n",
    "                              ['HI.4802.003.N712---N505.C25_P35', 'bi2'],\n",
    "                              ['HI.4803.001.N705---N517.C84_P35', 'omega'],\n",
    "                              ['HI.4803.001.N711---N507.C3_P35', 'ai1'],\n",
    "                              ['HI.4803.003.N706---N506.F56_P35', 'bi4']]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b9d499d-c85d-4661-a9dd-5c3acb35e813",
   "metadata": {},
   "source": [
    "## Fig S18"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b15124e5-39a4-4a4d-886b-43865ada7633",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(ncols=2, nrows=2, figsize=[7,5])\n",
    "\n",
    "for ((cross, intron), df), ax_idx in zip(intron_calls.loc[intron_calls['class']=='mobility'].groupby(['cross','intron']),\n",
    "                                        itertools.product(range(2), range(2))):\n",
    "    df = df.set_index('filename', drop=False)\n",
    "    itc = introns_to_check.loc[(introns_to_check['intron']==intron) & (introns_to_check['cross']==cross)].iloc[0]\n",
    "    bp1, bp2 = itc[['bp1', 'bp2']].values\n",
    "    \n",
    "    S = STRAIN_ORDER_MARKERS[cross] + list(parents_dict[cross])\n",
    "    \n",
    "    ax = axes[ax_idx]\n",
    "    \n",
    "    for Window, bp in zip([np.arange(-100,0), np.arange(0,100)], [bp1, bp2]):\n",
    "        window = range(bp-50, bp+50)\n",
    "        \n",
    "        xticklabels = np.repeat([bp1, bp2], 3) + np.array([-30, 0, 30, -30, 0, 30])\n",
    "        Xticks = np.array([-80, -50, -20, 20, 50, 80])\n",
    "        \n",
    "        \n",
    "        for s in S:\n",
    "            if s in parents_dict[cross]:\n",
    "                c = parents_color[s.split('.')[-1]]\n",
    "                lw = 2\n",
    "                z = 2\n",
    "                alpha = 1\n",
    "            elif s in df['filename'].values:\n",
    "                c = 'k'\n",
    "                lw = 2\n",
    "                z = 1\n",
    "                alpha = 1\n",
    "                \n",
    "            else:\n",
    "                c = 'k'\n",
    "                lw = 0.5\n",
    "                z = 0\n",
    "                alpha = 0.5\n",
    "\n",
    "            depth = DEPTH[s].set_index('pos')\n",
    "            bp1_profile = depth.loc[window]\n",
    "\n",
    "            ax.plot(Window, bp1_profile['depth']/np.quantile(bp1_profile['depth'], 0.8), color=c, lw=lw, zorder=z, alpha=alpha)\n",
    "    \n",
    "    fa = FancyArrow(0, 1.11, 0, -1.3, fc='white', width=3, head_length=0, head_width=0, lw=0, clip_on=False, zorder=3)\n",
    "    ax.add_patch(fa)\n",
    "    \n",
    "    for x in (-50, 50):\n",
    "        ax.axvline(x, ls='--', c='k', alpha=0.3, lw=3, zorder=-1)\n",
    "    \n",
    "    ax.set_ylim(-0.1, 1.1)\n",
    "    ax.set_ylabel('rel depth of cov')\n",
    "    \n",
    "    ax.set_xticks(Xticks)\n",
    "    ax.set_xticklabels(xticklabels, rotation=45, ha='right')\n",
    "    \n",
    "    ax.set_title(f'{cross} {pres_abs_poly_alias[intron]}', size=14)\n",
    "    \n",
    "    #ax_idx += 1\n",
    "    \n",
    "plt.tight_layout()\n",
    "sns.despine()\n",
    "#plt.savefig('/home/mathieu/mhenault_landrylab/Publications/mito_ma/resubmission2_GRes/fig/mobility_intron_junctions.svg', dpi=300)\n",
    "#plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f8f6c8e-bb26-465c-8346-479cab9283b5",
   "metadata": {},
   "source": [
    "## Fig S19"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ae9109d-8859-4f5e-9f97-d05f1bb04180",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=[8,10])\n",
    "gs = plt.GridSpec(ncols=1, nrows=2, height_ratios=[14,1], hspace=0, left=0.12, top=0.99, right=0.97, bottom=0.05)\n",
    "\n",
    "xlim = (-500,ref_genome_length+500)\n",
    "\n",
    "ax = fig.add_subplot(gs[0])\n",
    "y = 0\n",
    "for cross in cross_order:\n",
    "\n",
    "    if cross in intron_calls.loc[(intron_calls['class']=='rec_intron'), 'cross'].values:\n",
    "        \n",
    "        markers = MARKERS[cross]\n",
    "        vcf_melt = VCF_MELT[cross]\n",
    "        vcf_melt = vcf_melt.loc[(vcf_melt['marker']) & (vcf_melt['higher'])]\n",
    "        \n",
    "        ic = intron_calls.loc[(intron_calls['class']=='rec_intron') & (intron_calls['cross']==cross)]\n",
    "        \n",
    "        for s, df in ic.groupby('filename'):\n",
    "            tracts = TRACTS.loc[TRACTS['strain']==s]\n",
    "            if tracts.shape[0]>0:\n",
    "                alpha = 0.3\n",
    "                for i in tracts.index:\n",
    "                    (start, end, parent) = tracts.loc[i, ['start','end','parent']]\n",
    "\n",
    "                    c = parents_color[parent.split('.')[-1]]\n",
    "                    if start < end:\n",
    "                        fa = FancyArrow(start, y, end-start, 0, width=0.3, head_length=0, head_width=0, color=c, lw=0, alpha=alpha)\n",
    "                        ax.add_patch(fa)\n",
    "                    elif start > end:\n",
    "                        fa1 = FancyArrow(0, y, end, 0, width=0.3, head_length=0, head_width=0, color=c, lw=0, alpha=alpha)\n",
    "                        fa2 = FancyArrow(start, y, ref_genome_length-start, 0, width=0.3, head_length=0, head_width=0, color=c, lw=0, alpha=alpha)\n",
    "                        ax.add_patch(fa1)\n",
    "                        ax.add_patch(fa2)\n",
    "\n",
    "                vcf_sub = vcf_melt.set_index('filename').loc[s]\n",
    "                for parent, df1 in vcf_sub.groupby('parent'):\n",
    "                    c = parents_color[parent.split('.')[-1]]\n",
    "                    ax.scatter(df1['POS'], np.repeat(y, df1.shape[0]), s=6, color=c)\n",
    "            \n",
    "            ax.text(-500, y, f'{ma_strains.loc[s, \"mt_haplotype\"]} ({ma_strains.loc[s, \"cross\"]})', ha='right', va='center', size=9)\n",
    "            \n",
    "            for i in ic.loc[ic['filename']==s].index:\n",
    "                intron, bp, pmb, bp_side = ic.loc[i, ['intron', 'rec_bp', 'rec_pmb', 'rec_bp_side']]\n",
    "                c = parents_color[pmb.split('.')[-1]]\n",
    "                if bp_side == 'right':\n",
    "                    dx = 4e3\n",
    "                elif bp_side == 'left':\n",
    "                    dx = -4e3\n",
    "                #ya = y+0.25\n",
    "                ya = y+0.3\n",
    "                if (s == 'HI.4803.003.N706---N506.F56_P35' and intron == 'bi5') or\\\n",
    "                (s == 'NS.1250.002.N706---N507.D28_P35' and intron == 'bi1beta') or\\\n",
    "                (s == 'HI.4803.001.N701---N506.D73_P35' and intron == 'bi1beta'):\n",
    "                    #ya += 0.25\n",
    "                    ya += 0.3\n",
    "                fc = 'white'\n",
    "                c = parents_color[pmb.split('.')[-1]]\n",
    "                if [s, intron] in intron_call_rec_consistent:\n",
    "                    fc = parents_color[pmb.split('.')[-1]]\n",
    "                    c = 'white'\n",
    "                fa = FancyArrow(bp, ya, dx, 0, width=0.15, head_length=500, head_width=0.3, fc=fc, lw=0.5, ec=c)\n",
    "                ax.add_patch(fa)\n",
    "                ax.text(bp, ya, pres_abs_poly_alias[intron], ha=bp_side, va='center', size=7)\n",
    "            \n",
    "            y += 1\n",
    "\n",
    "ax.set_ylim(-1,y)\n",
    "ax.set_xlim(xlim)\n",
    "ax.axis('off')\n",
    "            \n",
    "# plot GFF entries\n",
    "ax = fig.add_subplot(gs[1])\n",
    "\n",
    "for i in ['left','right','top']:\n",
    "    ax.spines[i].set_visible(False)\n",
    "ax.arrow(0, 1, ref_genome_length, 0, color='0.9', lw=0, width=1, head_length=0, head_width=0, zorder=-1)\n",
    "\n",
    "legend_elms = []\n",
    "for at in annot_type_order:\n",
    "    if at != 'gc_cluster':\n",
    "        l = annot_type_alias[at]\n",
    "        fc = annot_type_color[at]\n",
    "        lw = 0\n",
    "        if fc == 'white':\n",
    "            lw = 1\n",
    "        legend_elms.append(Line2D([0], [0], color='w', marker='s', ms=9, mfc=fc, mec='black', mew=lw, label=l))\n",
    "ax.legend(handles=legend_elms, ncol=6, loc=9, bbox_to_anchor=(0.5, 1.1), frameon=False,\n",
    "         borderpad=0.0, labelspacing=0.2, handlelength=0.3, columnspacing=1.5)\n",
    "\n",
    "for i in artificial_genome_feat.loc[~artificial_genome_feat['annot_type'].isin(['gc_cluster','other'])].\\\n",
    "sort_values(by='annot_plot_order', ascending=False).index:\n",
    "    start, end, color, w, z = artificial_genome_feat.loc[i, [3,4,'annot_color','annot_width','annot_plot_order']]\n",
    "    ax.arrow(start, 1, end-start, 0, color=color, lw=0, width=w, head_length=0, head_width=0, zorder=z)\n",
    "ax.set_xlim(xlim)\n",
    "ax.set_ylim(0.45, 3)\n",
    "ax.set_xticks(np.arange(0, 81e3, 1e4))\n",
    "ax.set_xticklabels(range(0,90,10))\n",
    "ax.set_xlabel('kb')\n",
    "ax.set_yticks([])\n",
    "\n",
    "\n",
    "#plt.savefig('/home/mathieu/mhenault_landrylab/Publications/mito_ma/resubmission2_GRes/fig/rec_intron.svg', dpi=300)\n",
    "#plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "725a3f59-5b78-4776-b505-774a424792e9",
   "metadata": {},
   "source": [
    "# de novo mutations\n",
    "## Identify candidate de novo variants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa416aee-3f86-4a3e-9494-62362eb3b37d",
   "metadata": {},
   "outputs": [],
   "source": [
    "PRIV_CAND = {}\n",
    "min_dp = 5\n",
    "min_ratio = 0.8\n",
    "\n",
    "lines_fn_to_include = {cross:ma_strains.loc[(ma_strains['cross']==cross) & (ma_strains['identity_filter']), 'filename'].values for cross in cross_order}\n",
    "\n",
    "for cross, vcf_melt in VCF_MELT.items():\n",
    "    private_candidates = []\n",
    "    for (v, gt), df in vcf_melt.loc[(vcf_melt['filename'].isin(lines_fn_to_include[cross])) &\n",
    "                                   (vcf_melt['dp']>=min_dp) & \n",
    "                                   (vcf_melt['ratio']>=min_ratio)].groupby(['var_uid','gt']):\n",
    "        if len(set(df['line'].values)) == 1:\n",
    "            fn = set(df['filename'])\n",
    "            private_candidates.extend(list(df.index))\n",
    "    private_candidates = vcf_melt.loc[private_candidates].copy().reset_index(drop=True)\n",
    "    \n",
    "    # check if the allele is in any of the parents\n",
    "    print(f'{cross} checking parental variants...')\n",
    "    vcf_melt_merge = []\n",
    "    for cross2, vcf_melt2 in VCF_MELT.items():\n",
    "        #if cross2 != cross:\n",
    "        vcf_melt2 = VCF_MELT[cross2]\n",
    "        vcf_melt2 = vcf_melt2.loc[(vcf_melt2['filename'].isin(parents_dict[cross2])) &\n",
    "                                  (~vcf_melt2['gt'].isna()) &\n",
    "                                  (vcf_melt2['dp']>=min_dp) &\n",
    "                                  (vcf_melt2['ratio']>=min_ratio)]\n",
    "        vcf_melt_merge.append(vcf_melt2)\n",
    "    vcf_melt_merge = pd.concat(vcf_melt_merge)\n",
    "    \n",
    "    private_candidates['parent_filter'] = True\n",
    "    for (v, s, gt, POS, REF, ALT), df in private_candidates.groupby(['var_uid','line','gt','POS','REF','ALT']):\n",
    "        sub = vcf_melt_merge.loc[(vcf_melt_merge['POS']==POS) &\n",
    "                                 (vcf_melt_merge['REF']==REF) &\n",
    "                                 (vcf_melt_merge['ALT']==ALT) &\n",
    "                                 (vcf_melt_merge['gt']==gt)]\n",
    "        if sub.shape[0] > 0:\n",
    "            private_candidates.loc[df.index, 'parent_filter'] = False\n",
    "    \n",
    "    # check if the non-parent allele is not in any other line\n",
    "    print(f'{cross} checking lines variants...')\n",
    "    vcf_melt_merge = []\n",
    "    for cross2, vcf_melt2 in VCF_MELT.items():\n",
    "        if cross2 != cross:\n",
    "            vcf_melt2 = VCF_MELT[cross2]\n",
    "            vcf_melt2 = vcf_melt2.loc[(vcf_melt2['filename'].isin(lines_fn_to_include[cross2])) & \n",
    "                                      (~vcf_melt2['gt'].isna()) & \n",
    "                                      (vcf_melt2['dp']>=min_dp) &\n",
    "                                      (vcf_melt2['ratio']>=min_ratio)]\n",
    "            vcf_melt_merge.append(vcf_melt2)\n",
    "    vcf_melt_merge = pd.concat(vcf_melt_merge)\n",
    "    \n",
    "    private_candidates['lines_filter'] = private_candidates['parent_filter']\n",
    "    for (v, s, gt, POS, REF, ALT), df in private_candidates.loc[private_candidates['lines_filter']].groupby(['var_uid','line','gt','POS','REF','ALT']):\n",
    "        sub = vcf_melt_merge.loc[(vcf_melt_merge['POS']==POS) &\n",
    "                                 (vcf_melt_merge['REF']==REF) &\n",
    "                                 (vcf_melt_merge['ALT']==ALT) &\n",
    "                                 (vcf_melt_merge['gt']==gt)]\n",
    "        if sub.shape[0] > 0:\n",
    "            private_candidates.loc[df.index, 'lines_filter'] = False\n",
    "    \n",
    "    PRIV_CAND[cross] = private_candidates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f07b948-4719-4ab5-bf03-fdc62e7b4d73",
   "metadata": {},
   "outputs": [],
   "source": [
    "for cross, priv_cand in PRIV_CAND.items():\n",
    "    priv_cand['cross'] = cross\n",
    "    PRIV_CAND[cross] = priv_cand\n",
    "\n",
    "PRIV_CAND = pd.concat(PRIV_CAND.values()).reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "20b11b73-fede-486e-abb8-bfbffd76adde",
   "metadata": {},
   "outputs": [],
   "source": [
    "# get proportion of lines with defined genotypes for each variant\n",
    "\n",
    "for (cross, v), df in PRIV_CAND.groupby(['cross','var_uid']):\n",
    "    vcf_melt = VCF_MELT[cross]\n",
    "    vcf_melt = vcf_melt.loc[(vcf_melt['filename'].isin(lines_fn_to_include[cross])) &\n",
    "                            (vcf_melt['var_uid']==v)]\n",
    "\n",
    "    PRIV_CAND.loc[df.index, 'missing_ratio'] = vcf_melt['gt'].isna().sum()/vcf_melt.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35b2ca73-ffea-4039-8f5b-66cbfd020713",
   "metadata": {},
   "outputs": [],
   "source": [
    "PRIV_CAND['snv'] = (PRIV_CAND['REF'].apply(lambda x: len(x)==1)) & (PRIV_CAND['ALT'].apply(lambda x: len(x)==1))\n",
    "PRIV_CAND['var_len'] = PRIV_CAND.apply(lambda x: np.abs(len(x['REF'])-len(x['ALT'])), axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b93439a6-5eee-4516-ac12-3633de4d5a5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "#filter out variants with more than one alt\n",
    "PRIV_CAND['single_alt'] = True\n",
    "for (cross, pos, ref), c in PRIV_CAND.value_counts(['cross','POS','REF']).items():\n",
    "    if c > 1:\n",
    "        PRIV_CAND.loc[(PRIV_CAND['cross']==cross) & (PRIV_CAND['POS']==pos) & (PRIV_CAND['REF']==ref), 'single_alt'] = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "035f78de-8eb2-4205-b856-79c6f7de4e13",
   "metadata": {},
   "outputs": [],
   "source": [
    "PRIV_CAND['true_snv'] = ((PRIV_CAND['parent_filter']) &\n",
    "                         (PRIV_CAND['lines_filter']) &\n",
    "                         (PRIV_CAND['snv']) &\n",
    "                         (PRIV_CAND['single_alt']) &\n",
    "                         (PRIV_CAND['gt']==1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f7ef87c-3719-4b58-8130-60411efabe01",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# inspect the supporting reads for each variant\n",
    "for (cross, v), df in PRIV_CAND.loc[PRIV_CAND['true_snv']].groupby(['cross','var_uid']):\n",
    "    \n",
    "    fn, POS, REF, ALT, gt = df.iloc[0].loc[['filename','POS','REF','ALT','gt']]\n",
    "    if gt == 1:\n",
    "        SEQ = ALT\n",
    "    elif gt == 0:\n",
    "        SEQ = REF\n",
    "    \n",
    "    count_valid = 0\n",
    "    \n",
    "    samfile = pysam.AlignmentFile(f'/mnt/HDD3/mito_ma/bam/{fn}.mt.rmdup.rg.bam', 'rb')\n",
    "    POS -= 1\n",
    "    al = len(SEQ)\n",
    "    supporting_reads = []\n",
    "    for x in samfile.fetch('mt_art', POS, POS+al):\n",
    "        ap_dict = {j:i for (i,j) in x.aligned_pairs}\n",
    "        #only consider reads that entirely span the variant length\n",
    "        if (POS in ap_dict) and (POS+al in ap_dict):\n",
    "            if (ap_dict[POS] != None) and (ap_dict[POS+al] != None):\n",
    "                rl = x.reference_length\n",
    "                a_seq = x.query_sequence[ap_dict[POS]:ap_dict[POS]+al]\n",
    "                if a_seq == SEQ and rl < 161 and rl > 141:\n",
    "                    count_valid += 1\n",
    "                    \n",
    "    PRIV_CAND.loc[df.index, 'valid_support_reads'] = count_valid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d374fc41-e88e-4f52-aa46-9686ddf35d68",
   "metadata": {},
   "outputs": [],
   "source": [
    "#perform final filtering; if any candidate is found elsewhere with high enough relative support, discard\n",
    "for (cross, fn, POS, REF, ALT), df in PRIV_CAND.loc[PRIV_CAND['true_snv']].groupby(['cross','filename','POS','REF','ALT']):\n",
    "    other_support = []\n",
    "    for cross2 in cross_order:\n",
    "        vcf_melt = VCF_MELT[cross2]\n",
    "        vcf_melt = vcf_melt.loc[(vcf_melt['filename']!=fn) & \n",
    "                                (vcf_melt['POS']==POS) &\n",
    "                                (vcf_melt['REF']==REF) &\n",
    "                                (vcf_melt['ALT']==ALT)]\n",
    "        if vcf_melt.shape[0] > 0:\n",
    "            other_support.extend(vcf_melt['ao'])\n",
    "    \n",
    "\n",
    "    if len(other_support) > 0:\n",
    "        other_support = np.array(other_support)\n",
    "        other_sum = np.nansum(other_support)\n",
    "        other_n = other_support.shape[0]\n",
    "        \n",
    "    else:\n",
    "        other_sum = 0\n",
    "        other_n = 0\n",
    "    \n",
    "    PRIV_CAND.loc[df.index, 'other_sum'] = other_sum\n",
    "    PRIV_CAND.loc[df.index, 'other_n'] = other_n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4172c494-682b-4447-9c7c-368bf1876089",
   "metadata": {},
   "outputs": [],
   "source": [
    "display = ['cross', 'line', 'passage', '#CHROM', 'POS', 'REF', 'ALT', 'dp', 'ro', 'ao', 'missing_ratio', 'valid_support_reads','other_sum']\n",
    "best_cand_snv = PRIV_CAND.loc[PRIV_CAND['true_snv']]\n",
    "best_cand_snv = best_cand_snv.loc[(best_cand_snv['ao'] >= (best_cand_snv['other_sum']*2)) &\n",
    "                                  (best_cand_snv['valid_support_reads'] >= 2), display].reset_index(drop=True)\n",
    "best_cand_snv['annot'] = best_cand_snv['POS'].apply(lambda x: artificial_genome_feat.loc[pos_func_annot[x], 'Name'])\n",
    "best_cand_snv['annot_type'] = best_cand_snv['POS'].apply(lambda x: artificial_genome_feat.loc[pos_func_annot[x], 'annot_type'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "135f59aa-3d14-4b1b-a3d7-ed0198706219",
   "metadata": {},
   "source": [
    "## Table S5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15a52e19-791c-4b2b-b66d-6393069a566e",
   "metadata": {},
   "outputs": [],
   "source": [
    "#export candidate de novo snv\n",
    "#best_cand_snv.to_csv('/mnt/HDD3/mito_ma/results/best_cand_snv.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb14eb90-8024-4e0e-ab46-6b457f18d457",
   "metadata": {},
   "source": [
    "# Nanopore assemblies of lines\n",
    "## Parse nanopore libraries metadata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e01dd994-e423-4f04-b333-202d839f2d81",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "assemblies_lines = pd.read_table('/mnt/HDD3/mito_nanopore/mugsy/assemblies_lines.txt', header=None)\n",
    "assemblies_lines = pd.concat([assemblies_lines,\n",
    "                              assemblies_lines.apply(lambda x: pd.Series(x[0].split('.'), index=['strain','k','p','l']), axis=1)], axis=1)\n",
    "assemblies_lines.index = assemblies_lines[0].values\n",
    "assemblies_lines['cross'] = ma_strains.groupby('strain')['cross'].apply(lambda x: x.iloc[0]).loc[assemblies_lines['strain']].values\n",
    "\n",
    "assemblies_lines['cross_order'] = assemblies_lines['cross'].apply(lambda x: cross_order[x])\n",
    "\n",
    "for s, df in assemblies_lines.groupby('strain'):\n",
    "    \n",
    "    assemblies_lines.loc[df.index, 'identity_filter'] = ma_strains.set_index(['strain','passage']).loc[(s, 35), 'identity_filter'].iloc[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab215601-1529-45b2-aed7-8d883ace82a8",
   "metadata": {},
   "source": [
    "## Import assemblies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d83976e4-b7dd-4dd2-96f6-52db52374b2d",
   "metadata": {},
   "outputs": [],
   "source": [
    "CNS_LINES = {}\n",
    "\n",
    "for s in assemblies_lines.index:\n",
    "    CNS_LINES[s] = {seq.id: seq for seq in SeqIO.parse(f'/mnt/HDD3/mito_nanopore/assemblies_lines/{s}/consensus.fasta', 'fasta')}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac0967da-0902-4bec-aaef-ac4bc141308a",
   "metadata": {},
   "outputs": [],
   "source": [
    "#import atp6-splitted assemblies\n",
    "CNS_LINES_ATP6 = {}\n",
    "\n",
    "for s in assemblies_lines.index:\n",
    "    path = f'/mnt/HDD3/mito_nanopore/assemblies_lines/{s}/consensus.atp6.fasta'\n",
    "    if os.path.exists(path):\n",
    "        CNS_LINES_ATP6[s] = {seq.id: seq for seq in SeqIO.parse(f'/mnt/HDD3/mito_nanopore/assemblies_lines/{s}/consensus.atp6.fasta', 'fasta')}\n",
    "    else:\n",
    "        CNS_LINES_ATP6[s] = CNS_LINES[s]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e76226e-1bdc-49a8-ab64-1449f9a3383e",
   "metadata": {},
   "outputs": [],
   "source": [
    "for s in assemblies_lines.index:\n",
    "    n_tigs = len(CNS_LINES[s])\n",
    "    len_tigs = sum([len(tig.seq) for tig in CNS_LINES[s].values()])\n",
    "    assemblies_lines.loc[s, 'n_tigs'] = n_tigs\n",
    "    assemblies_lines.loc[s, 'len_tigs'] = len_tigs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "570577a0-38bf-4d89-9649-278948bed715",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Split contigs at ATP6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8725f959-3e4b-484b-8ecd-5792899947f4",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "idx = 0\n",
    "with ProgressBar(max_value=assemblies_lines.shape[0]) as bar:\n",
    "    for s in assemblies_lines.index:\n",
    "        path_tab = f'/mnt/HDD3/mito_nanopore/assemblies_lines/{s}/tblastn_atp6.consensus.tab'\n",
    "        if getsize(path_tab) > 0:\n",
    "            tblastn = pd.read_csv(path_tab, sep='\\t', header=None)\n",
    "            assembly = {seq.id:seq for seq in SeqIO.parse(f'/mnt/HDD3/mito_nanopore/assemblies_lines/{s}/consensus.fasta', 'fasta')}\n",
    "            start, end = tblastn[[8,9]].iloc[0].astype(int)\n",
    "            if start < end:\n",
    "                b = start-1\n",
    "            else:\n",
    "                b = start\n",
    "            c = tblastn[1].iloc[0]\n",
    "            c0 = SeqRecord.SeqRecord(assembly[c].seq[:b], id=f'{c}.0', description='')\n",
    "            c1 = SeqRecord.SeqRecord(assembly[c].seq[b:], id=f'{c}.1', description='')\n",
    "            del assembly[c]\n",
    "            assembly[f'{c}.0'] = c0\n",
    "            assembly[f'{c}.1'] = c1\n",
    "            #SeqIO.write(assembly.values(), f'/mnt/HDD3/mito_nanopore/assemblies_lines/{s}/consensus.atp6.fasta', 'fasta')\n",
    "        idx += 1\n",
    "        bar.update(idx)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "030e90b6-5de5-4c2a-ad09-07e7a6a3de5f",
   "metadata": {},
   "source": [
    "## Import contig alignments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2fa4ee94-83ec-4f81-8bd9-8d275c609087",
   "metadata": {},
   "outputs": [],
   "source": [
    "coords_lines = {}\n",
    "for s in assemblies_lines.index:\n",
    "    coords = pd.read_csv(f'/mnt/HDD3/mito_nanopore/mummer_lines/{s}.artificial_genome.coords', sep='\\t', skiprows=4, header=None)\n",
    "    coords['assembly'] = s\n",
    "    coords['strain'] = s.split('.')[0]\n",
    "    coords_lines[s] = coords"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7fb2110-c695-4852-93e9-e9da9f7bfe82",
   "metadata": {},
   "source": [
    "## Extract assemblies with deletions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74d97e39-c510-4e89-8928-852201bed429",
   "metadata": {},
   "outputs": [],
   "source": [
    "line_order_deletion = {}\n",
    "lod_idx = 0\n",
    "for cross in cross_order:\n",
    "    df = assemblies_lines.loc[assemblies_lines['cross']==cross]\n",
    "    for s, df1 in df.groupby('strain'):\n",
    "        if (df1['len_tigs'].mean() < 60000):\n",
    "        \n",
    "            line_order_deletion[s] = lod_idx\n",
    "            lod_idx += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b003730-1084-42d6-92a7-84b292e12859",
   "metadata": {},
   "source": [
    "## Fig S37"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a7ade67-c993-45cf-947c-b45bed7e78ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=[8,8])\n",
    "gs = plt.GridSpec(nrows=2, ncols=1, height_ratios=[4,1], hspace=0.1,\n",
    "                 left=0.05, right=0.93, top=0.97, bottom=0.06)\n",
    "xlim = (-500,ref_genome_length+500)\n",
    "\n",
    "ax = fig.add_subplot(gs[0])\n",
    "for i in ['right','top']:\n",
    "    ax.spines[i].set_visible(False)\n",
    "    \n",
    "for s, df in assemblies_lines.groupby('strain'):\n",
    "    if s in line_order_deletion:\n",
    "        \n",
    "        y = line_order_deletion[s]\n",
    "        y_offset = 0\n",
    "        for sa in df.index:\n",
    "            c = cross_color[assemblies_lines.loc[sa, 'cross']]\n",
    "            coords = coords_lines[sa]\n",
    "            #coords = coords.loc[coords[4] >= 1000]\n",
    "\n",
    "            for i in coords.index:\n",
    "                ax.plot(coords.loc[i, [0,1]], np.repeat(y+y_offset, 2), c, lw=1.5)\n",
    "                \n",
    "            y_offset += 0.05\n",
    "\n",
    "ax.set_ylim(-0.25, len(line_order_deletion)-0.25)\n",
    "ax.set_yticks(np.arange(len(line_order_deletion))+0.25)\n",
    "ax.set_yticklabels(pd.Series(line_order_deletion).sort_values().index)\n",
    "ax.set_xlim(xlim)\n",
    "ax.set_xticks(np.arange(0, 81e3, 1e4))\n",
    "ax.set_xticklabels(range(0,90,10))\n",
    "\n",
    "ax.xaxis.set_minor_locator(MultipleLocator(1000))\n",
    "\n",
    "ax.grid(axis='x', which='minor', lw=0.5)\n",
    "ax.grid(axis='x', which='major', lw=1.5)\n",
    "\n",
    "for cross, dy in zip(['CC1', 'BC2', 'BA1', 'BA2', 'BSc1', 'BSc2'],\n",
    "                     [(0,0), (1,1), (2,3), (4,6), (7,8), (9,14)]):\n",
    "    \n",
    "    y = np.mean(dy)+0.25\n",
    "    ax.arrow(8.35e4, y, 5e3, 0, color=cross_color[cross], lw=0, width=(dy[1]-dy[0])+0.9,\n",
    "             head_length=0, head_width=0, clip_on=False)\n",
    "    ax.text(8.6e4, y, cross, color='white', ha='center', va='center', size=10)\n",
    "\n",
    "# plot GFF entries\n",
    "\n",
    "ax = fig.add_subplot(gs[1])\n",
    "xlim = (-500, ref_genome_length+500)\n",
    "ax.arrow(0, 1, ref_genome_length, 0, color='0.9', width=1, head_length=0, head_width=0, zorder=-1)\n",
    "\n",
    "for i in artificial_genome_feat.loc[~artificial_genome_feat['annot_type'].isin(['gc_cluster','other'])].sort_values(by='annot_plot_order', ascending=False).index:\n",
    "    start, end, color, w, z = artificial_genome_feat.loc[i, [3,4,'annot_color','annot_width','annot_plot_order']]\n",
    "    ax.arrow(start, 1, end-start, 0, color=color, width=w, head_length=0, head_width=0, zorder=z)\n",
    "\n",
    "#create linked labels\n",
    "pap_sub = [a for a in pres_abs_poly if a in artificial_genome_feat['Name'].values]\n",
    "for x, a in zip(np.linspace(-4e3, ref_genome_length+6e3, len(pap_sub)),\n",
    "                pap_sub):\n",
    "\n",
    "    fc = at_color_hm[at_dict[a]]\n",
    "    ec = 'white'\n",
    "    tc = 'white'\n",
    "    if fc == 'white':\n",
    "        tc = 'black'\n",
    "        ec = 'black'\n",
    "    if fc == 'limegreen':\n",
    "        tc = 'black'\n",
    "\n",
    "    t = ax.text(x, 6, pres_abs_poly_alias[a], rotation=90, ha='center', va='top', color=tc, size=7.5,\n",
    "                 bbox=dict(ec=ec, fc=fc, lw=0.5, boxstyle='square,pad=0.12'), zorder=1)\n",
    "    pos = artificial_genome_feat.loc[artificial_genome_feat['Name']==a].iloc[0,3]\n",
    "    ax.plot([pos, x, x], [1.5, 3, 6], lw=0.5, color='black', zorder=-1, clip_on=False)\n",
    "\n",
    "ax.set_xticks(np.arange(0,83e3,10e3))\n",
    "ax.set_xticklabels(np.arange(0,83,10))\n",
    "ax.set_xlabel('kb')\n",
    "ax.xaxis.set_minor_locator(MultipleLocator(1000))\n",
    "ax.set_ylim(0.5, 6)\n",
    "ax.set_yticks([])\n",
    "ax.set_xlim(xlim)\n",
    "for i in ['left','right','top']:\n",
    "    ax.spines[i].set_visible(False)\n",
    "\n",
    "#plt.savefig(f'/home/mathieu/mhenault_landrylab/Publications/mito_ma/resubmission2_GRes/fig/deletion_lr.svg', dpi=300)\n",
    "#plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd7d1971-4649-4e4f-81d6-41fc76f65ef7",
   "metadata": {},
   "source": [
    "# petite frequency"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0c80b397-6264-4dce-a72e-2dbc9a9171d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "petite_count = pd.read_excel('/home/mathieu/mhenault_landrylab/Experiments/screen_glycerol/petite_test/2022_07_01/counts.xlsx', sheet_name='Sheet1')\n",
    "petite_count = pd.melt(petite_count.loc[~petite_count['large'].isna()], id_vars=['strain', 'image', 'colony', 'medium'], var_name='size', value_name='count')\n",
    "petite_hap = petite_count.pivot_table(index='strain', columns='size', values='count', aggfunc=np.mean)\n",
    "petite_hap['freq_petite'] = (petite_hap['small']/(petite_hap['small']+petite_hap['large']))*100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf36853f-efdc-4c7c-bad4-fb49ec3a141a",
   "metadata": {},
   "outputs": [],
   "source": [
    "#extract frequencies of non-respiring lines at all timepoints\n",
    "petite_cross = GDR.loc[(GDR['identity_filter']!=False)].value_counts(['Cross','resp']).rename('count').reset_index()\\\n",
    ".pivot_table(index='Cross', columns='resp', values='count', aggfunc=lambda x: x)\n",
    "petite_cross['freq_resp_loss'] = petite_cross[False]/(petite_cross[True] + petite_cross[False])*100\n",
    "\n",
    "for cross, parents in parents_dict.items():\n",
    "    parents = [p.split('.')[-1] for p in parents]\n",
    "    mean_petite = petite_hap.loc[parents, 'freq_petite'].mean()\n",
    "    petite_cross.loc[cross, 'freq_petite'] = mean_petite"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "23efaa87-3363-44ea-9d44-8d62f5ae8c86",
   "metadata": {},
   "outputs": [],
   "source": [
    "petite_stock = pd.read_excel('/home/mathieu/mhenault_landrylab/Experiments/screen_glycerol/petite_test/2022_07_10/counts.xlsx',\n",
    "                             sheet_name='Sheet1').set_index('strain')\n",
    "petite_stock['freq_petite'] = (petite_stock['small']/(petite_stock['small']+petite_stock['large']))*100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2cf479ec-fd18-4320-a07f-89dee255a7ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "inh_petite = gdrec.loc[(gdrec['resp']==False) & (gdrec['passage']==1)].value_counts(['cross','parent'], sort=False).rename('count').reset_index()\n",
    "inh_petite['total'] = gdrec.loc[(~gdrec['resp'].isna()) & (gdrec['passage']==1)].value_counts('cross', sort=False).rename('count')\\\n",
    ".loc[inh_petite['cross']].values\n",
    "inh_petite['frac_inh_petite'] = inh_petite['count']/inh_petite['total']*100\n",
    "inh_petite = inh_petite.loc[inh_petite['parent']!='rec']\n",
    "inh_petite['freq_petite'] = petite_stock.loc[inh_petite['parent'].values, 'freq_petite'].values"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab9e521c-d753-4d88-8f89-6c8cd618d82e",
   "metadata": {},
   "source": [
    "## Fig S33"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c4b731c7-237d-43b7-b8b5-be96f48a6f50",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=[8,7])\n",
    "gs = plt.GridSpec(nrows=2, ncols=2, wspace=0.5, hspace=0.4,\n",
    "                 bottom=0.12, left=0.1, right=0.85, top=0.96)\n",
    "\n",
    "# Spontaneous petite frequency\n",
    "ax = fig.add_subplot(gs[0,0])\n",
    "fig.text(0.02, 0.95, 'A', weight='bold', size=24)\n",
    "ax.bar(range(13), petite_hap.loc[parents_order.index, 'freq_petite'], color=[parents_color[p] for p in parents_order.index])\n",
    "ax.set_xticks(range(13))\n",
    "ax.set_xticklabels(parents_order.index, size=8, ha='right', rotation=45)\n",
    "ax.set_ylabel('petite rate (%)')\n",
    "\n",
    "ax = fig.add_subplot(gs[0,1])\n",
    "fig.text(0.45, 0.95, 'B', weight='bold', size=24)\n",
    "ax.scatter(petite_cross['freq_petite'], petite_cross['freq_resp_loss'], color=[cross_color[cross] for cross in petite_cross.index])\n",
    "lr = stats.linregress(petite_cross['freq_petite'], petite_cross['freq_resp_loss'])\n",
    "X = [0.4, 2.7]\n",
    "ax.plot(X, [x*lr.slope+lr.intercept for x in X], c='k', zorder=0)\n",
    "ax.text(0.1, 0.5, f'r={lr.rvalue:.2f}\\np={plot_pval_text(lr.pvalue)}', transform=ax.transAxes)\n",
    "ax.set_xlabel('mean parental petite rate (%)')\n",
    "ax.set_ylabel('% lines with respiration loss')\n",
    "\n",
    "# fraction of petite cells in stock cultures\n",
    "\n",
    "ax = fig.add_subplot(gs[1,0])\n",
    "fig.text(0.02, 0.45, 'C', weight='bold', size=24)\n",
    "ax.bar(range(13), petite_stock.loc[parents_order.index, 'freq_petite'], color=[parents_color[p] for p in parents_order.index])\n",
    "ax.set_xticks(range(13))\n",
    "ax.set_xticklabels(parents_order.index, size=8, ha='right', rotation=45)\n",
    "ax.set_ylabel('petite fraction in stock (%)')\n",
    "\n",
    "ax = fig.add_subplot(gs[1,1])\n",
    "fig.text(0.42, 0.45, 'D', weight='bold', size=24)\n",
    "ax.scatter(inh_petite['freq_petite'], inh_petite['frac_inh_petite'], color=[cross_color[c] for c in inh_petite['cross'].values])\n",
    "lr = stats.linregress(inh_petite['freq_petite'], inh_petite['frac_inh_petite'])\n",
    "X = [0.8, 9]\n",
    "ax.plot(X, [x*lr.slope+lr.intercept for x in X], c='k', zorder=0)\n",
    "ax.text(0.6, 0.5, f'r={lr.rvalue:.2f}\\np={plot_pval_text(lr.pvalue)}', transform=ax.transAxes)\n",
    "ax.set_xlabel('petite fraction in stock (%)')\n",
    "ax.set_ylabel('% non-recombinant\\ndeleted mtDNA haplotypes')\n",
    "\n",
    "ax = fig.add_subplot(gs[:, 1])\n",
    "ax.axis('off')\n",
    "legend_elms = [Line2D([0], [0], color='white', marker='o', ms=8, mfc=cross_color[cross], label=cross) for cross in cross_order]\n",
    "ax.legend(handles=legend_elms, ncol=1, loc=3, bbox_to_anchor=[1.02,0.3])\n",
    "\n",
    "sns.despine()\n",
    "#plt.savefig('/home/mathieu/mhenault_landrylab/Publications/mito_ma/resubmission2_GRes/fig/petite_freq.svg', dpi=300)\n",
    "#plt.show()\n",
    "plt.close()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  },
  "toc-showcode": false,
  "toc-showmarkdowntxt": false
 },
 "nbformat": 4,
 "nbformat_minor": 5
}