5-AverageTrace_ON.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.signal import savgol_filter\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# prep info\n",
    "# contact: c\n",
    "# status inlcude: r, s, a\n",
    "\n",
    "root_path = r'/Users/xiaoqiansun/Desktop/MedLu/TubeTest/Data'\n",
    "\n",
    "\n",
    "days = 6\n",
    "fpsN = 15\n",
    "fpsB = 30\n",
    "seconds = 5\n",
    "intervalLength = 20\n",
    "frames = seconds*fpsN\n",
    "baselinePeriod = 180 #(3min(180s) baseline)\n",
    "redundentTime = 190 #10s+3min\n",
    "\n",
    "\n",
    "M32_list = ['32-1_28', '32-2_18', '32-3_15', '32-4_20', '32-5_12', '32-6_15']\n",
    "M33_list = ['33-1_28', '33-2_35', '33-3_32', '33-4_30', '33-5_30', '33-6_26']\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Define"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to keep certain status frrame interval\n",
    "#----------------------------------------------------------------------------------\n",
    "def pick_ARInterval_ON(df, which_mouse, behavior, folderPath):      \n",
    "      \n",
    "    df1 = df.copy().reset_index(drop=True)\n",
    "    dfb = df1[df1[which_mouse]== behavior]\n",
    "    df1 = df1.drop(['mouse1', 'mouse2', 'contact'], axis=1)\n",
    "    dfb = dfb.drop(['mouse1', 'mouse2', 'contact'], axis=1)\n",
    "    \n",
    "    \n",
    "    # read in ON/OFF summary dataframe\n",
    "    file_name = 'ONOFF.csv'\n",
    "    on_off_df = pd.read_csv(os.path.join(folderPath, 'ONOFF.csv'))\n",
    "    columns = on_off_df.columns.to_list()\n",
    "    columns[0] = 'Neurons'\n",
    "    on_off_df.columns = columns\n",
    "    on_off_df = on_off_df.set_index('Neurons')\n",
    "    # get approach/retreat on neurons\n",
    "    if behavior == 'a':\n",
    "        ON_Neurons = on_off_df[on_off_df['approachON'] == 1].index.to_list()\n",
    "    elif behavior == 'r':\n",
    "        ON_Neurons = on_off_df[on_off_df['retreatON'] == 1].index.to_list()\n",
    "        \n",
    "    \n",
    "    #loc\n",
    "    if len(ON_Neurons) == 0:\n",
    "        return (pd.DataFrame(), pd.DataFrame())\n",
    "    else:\n",
    "        df1 = df1[ON_Neurons]\n",
    "        dfb = dfb[ON_Neurons]\n",
    "        return (df1, dfb)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get social interval list\n",
    "#----------------------------------------------------------------------------------\n",
    "def get_BonsetA(df, df_b, fps, seconds, intervalLength):\n",
    "    \n",
    "    # get behavior index\n",
    "    index_1_list = df_b.index.tolist()\n",
    "    \n",
    "    # get intervals list\n",
    "    if len(index_1_list) >= seconds*fps:\n",
    "        # get intervals list(>seconds*fps)\n",
    "        interval_list = []\n",
    "        interval_list.append(index_1_list[0])\n",
    "\n",
    "        for i in range(len(index_1_list)):\n",
    "            if i < len(index_1_list)-1:\n",
    "                if index_1_list[i+1] - index_1_list[i] > intervalLength:\n",
    "                    interval_list.append(index_1_list[i])\n",
    "                    interval_list.append(index_1_list[i+1])\n",
    "\n",
    "        interval_list.append(index_1_list[-1])\n",
    "\n",
    "        # split interval list into sublist\n",
    "        composite_interval_list = [interval_list[x:x+2] for x in range(0, len(interval_list),2)]\n",
    "\n",
    "        \n",
    "        df_Bonset_list = []\n",
    "        df_onsetA_list = []\n",
    "        # enlargy each interval 2# frames (# forward, # afterward)\n",
    "        for interval in composite_interval_list:\n",
    "            if interval[0] > seconds*fps:\n",
    "                Bonset_start = interval[0] - seconds*fps\n",
    "                Bonset_end = interval[0]\n",
    "                onsetA_start = interval[0]\n",
    "                if interval[0] + seconds*fps < len(df):\n",
    "                    onsetA_end = interval[0] + seconds*fps \n",
    "                    #----------------locate----------------\n",
    "                    Bonset_df = df.iloc[Bonset_start:Bonset_end]\n",
    "                    df_Bonset_list.append(Bonset_df)\n",
    "\n",
    "                    onsetA_df = df.iloc[onsetA_start:onsetA_end]\n",
    "                    df_onsetA_list.append(onsetA_df)\n",
    "            \n",
    "            \n",
    "    else: \n",
    "        df_Bonset_list = []\n",
    "        df_onsetA_list = []\n",
    "    \n",
    "    return(df_Bonset_list, df_onsetA_list)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# calculate mean of each mean df from a df list\n",
    "def calculate_avg_FF(df_list, frames):\n",
    "    \n",
    "    Mean_DF = pd.DataFrame()\n",
    "    \n",
    "    if len(df_list) > 0:\n",
    "        for i in range(len(df_list)):\n",
    "            if df_list[i].shape[0] == frames:\n",
    "                Mean_DF['mean'+str(i)] = df_list[i].mean(axis=1).values.tolist()\n",
    "        Mean_DF['MEAN'] = Mean_DF.mean(axis=1)\n",
    "    \n",
    "    return(Mean_DF)\n",
    "\n",
    "\n",
    "\n",
    "def combine_BA(B_list, A_list, mouse_list, diffDF_list, frames, mouse_name, day):\n",
    "    \n",
    "    if  len(B_list) > 0:\n",
    "        B_Mean = calculate_avg_FF(B_list, frames)\n",
    "        A_Mean = calculate_avg_FF(A_list, frames)\n",
    "\n",
    "        df_FF_Diff = {'mouse_name': mouse_name,\n",
    "                      'day':day,\n",
    "                      'Max-Max': max(A_Mean['MEAN'])-max(B_Mean['MEAN']),\n",
    "                      'Mean-Mean': np.mean(A_Mean['MEAN'])-np.mean(B_Mean['MEAN'])}\n",
    "        dic_FF_Diff = pd.DataFrame.from_dict(df_FF_Diff, orient='index').T\n",
    "        diffDF_list.append(dic_FF_Diff)\n",
    " \n",
    "        mouse_list.append( pd.DataFrame({'day'+str(day):B_Mean['MEAN'].values.tolist()+A_Mean['MEAN'].values.tolist()} ))\n",
    "    \n",
    "    return(mouse_list, diffDF_list)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_meanSEM_Summary(df_list):\n",
    "    \n",
    "    DF = pd.concat(df_list, axis=1)\n",
    "    \n",
    "    summary = pd.DataFrame()\n",
    "    summary['ALL_MICE_MEAN'] = DF.mean(axis = 1)\n",
    "    summary['MEAN_SEM'] = DF.mean(axis = 1) - DF.sem(axis = 1) \n",
    "    summary['MEANSEM'] = DF.mean(axis = 1) + DF.sem(axis = 1) \n",
    "    summary['SEM'] = DF.sem(axis = 1)\n",
    "    summary['MAX'] = DF.max(axis = 1)\n",
    "    summary['MIN'] = DF.min(axis = 1)\n",
    "        \n",
    "    return(summary)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Get Avg FF\n",
    "\n",
    "- approach ON around approach"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "m32Diff_list = []\n",
    "m33Diff_list = []\n",
    "m32_approachS = []\n",
    "m33_approachS = []\n",
    "\n",
    "\n",
    "for day in range(days):\n",
    "\n",
    "    # read in dataframe\n",
    "    m32_folder = os.path.join(root_path, M32_list[day])\n",
    "    m33_folder = os.path.join(root_path, M33_list[day])\n",
    "\n",
    "    # read in dataframe\n",
    "    m32_tube = pd.read_csv(os.path.join(m32_folder,'m32_tube.csv'), index_col = 'Frame')\n",
    "    m33_tube = pd.read_csv(os.path.join(m33_folder,'m33_tube.csv'), index_col = 'Frame')   \n",
    "\n",
    "    # filter on neuorns\n",
    "    m32_aAP, m32_AP = pick_ARInterval_ON(m32_tube, 'mouse1', 'a', m32_folder)\n",
    "    m33_aAP, m33_AP = pick_ARInterval_ON(m33_tube, 'mouse2', 'a', m33_folder)\n",
    "    \n",
    "    if len(m32_AP) != 0:\n",
    "        # separate onset intervals; update onset data & diff info\n",
    "        m32_BAP, m32_APA = get_BonsetA(m32_aAP, m32_AP, fpsN, seconds, intervalLength)\n",
    "        m32_approachS, m32Diff_list = combine_BA(m32_BAP, m32_APA, m32_approachS, m32Diff_list, frames, 'm32', day+1)\n",
    "    if len(m33_AP) != 0:\n",
    "        m33_BAP, m33_APA = get_BonsetA(m33_aAP, m33_AP, fpsN, seconds, intervalLength)\n",
    "        m33_approachS, m33Diff_list = combine_BA(m33_BAP, m33_APA, m33_approachS, m33Diff_list, frames, 'm33', day+1)\n",
    "\n",
    "\n",
    "FF32_Diff = pd.concat(m32Diff_list)\n",
    "FF32_Diff.to_excel('mouse32_'+str(seconds)+'_diff.xlsx')\n",
    "FF33_Diff = pd.concat(m33Diff_list)\n",
    "FF33_Diff.to_excel('mouse33_'+str(seconds)+'_diff.xlsx')\n",
    "\n",
    "BapproaceA_m32_SummaryS = generate_meanSEM_Summary(m32_approachS)\n",
    "BapproaceA_m33_SummaryS = generate_meanSEM_Summary(m33_approachS)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### plot Trace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_MeanSEM_fill(sum1, sum2, seconds, behavior, smooth=False):\n",
    "    \n",
    "    # get data\n",
    "    #--------------------------------------------------------\n",
    "    ySum1 =  sum1['ALL_MICE_MEAN'].values.tolist()\n",
    "    ySum1 = savgol_filter(ySum1, 35, 3)\n",
    "    ySum1_MM_SEM = sum1['MEAN_SEM'].values.tolist()\n",
    "    ySum1_MMSEM = sum1['MEANSEM'].values.tolist()\n",
    "    \n",
    "    ySum2 =  sum2['ALL_MICE_MEAN'].values.tolist()\n",
    "    ySum2_MM_SEM = sum2['MEAN_SEM'].values.tolist()\n",
    "    ySum2_MMSEM = sum2['MEANSEM'].values.tolist()\n",
    "    \n",
    "    x = sum1.index.values.tolist()\n",
    "    \n",
    "    \n",
    "    if smooth:\n",
    "        ySum1 = savgol_filter(ySum1, 35, 3)\n",
    "        ySum1_MM_SEM = savgol_filter(ySum1_MM_SEM, 35, 3)\n",
    "        ySum1_MMSEM = savgol_filter(ySum1_MMSEM, 35, 3)\n",
    "        ySum2 = savgol_filter(ySum2, 35, 3)\n",
    "        ySum2_MM_SEM = savgol_filter(ySum2_MM_SEM, 35, 3)\n",
    "        ySum2_MMSEM = savgol_filter(ySum2_MMSEM, 35, 3)\n",
    "        \n",
    "    #ymin = min(min(ySum1), min(ySum2), min(ySum1_MM_SEM), min(ySum2_MM_SEM))-0.1\n",
    "    #ymax = max(max(ySum1), max(ySum2), max(ySum1_MMSEM), max(ySum2_MMSEM))+0.1\n",
    "    ymin = min(min(ySum1), min(ySum2))-0.1\n",
    "    ymax = max(max(ySum1), max(ySum2))+0.1\n",
    "        \n",
    "    \n",
    "    # plot\n",
    "    #--------------------------------------------------------\n",
    "    plt.figure(figsize = (8,4))\n",
    "\n",
    "    plt.plot(x, ySum1, color = '#4f4f4f', lw=2, label='mouse32') ##black-WT\n",
    "    plt.plot(x, ySum2, color = '#FF7C80', lw=2, label='mouse33')\n",
    "    plt.plot([x[int(len(x)/2)],x[int(len(x)/2)]],[ymin+0.05,ymax-0.05] , '--r', lw = 2)\n",
    "\n",
    "    # fill\n",
    "    plt.fill_between(x, ySum1_MM_SEM, ySum1_MMSEM, color = '#dddddd', alpha = 0.5)\n",
    "    plt.fill_between(x, ySum2_MM_SEM, ySum2_MMSEM, color = '#ffd9da', alpha = 0.5)\n",
    "\n",
    "    plt.legend()\n",
    "    plt.ylim(ymin, ymax)\n",
    "    plt.gca().spines['right'].set_visible(False)\n",
    "    plt.gca().spines['top'].set_visible(False)\n",
    "    plt.gca().axes.get_xaxis().set_visible(False)\n",
    "\n",
    "    title = behavior+'_'+str(seconds)+'s_AVG_FF'\n",
    "    plt.savefig(title)\n",
    "    \n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# call\n",
    "plot_MeanSEM_fill(BapproaceA_m32_SummaryS, BapproaceA_m33_SummaryS, seconds, \n",
    "                  #'smoothed_approachONapproach', smooth=True\n",
    "                  'approachONapproach', smooth=False\n",
    "                 )\n",
    "                 \n",
    "                  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}