learned_tuning_NREM_QW_across_time.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Achilles_10252013\n",
      "Achilles_11012013\n",
      "This session has only one running direction\n",
      "Buddy_06272013\n",
      "Cicero_09172014\n",
      "Gatsby_08282013\n",
      "This session has only one running direction\n",
      "Kevin-maze1\n",
      "RatN_Day2_2019-10-11_03-58-54\n",
      "RatS-Day2-2020-11-27_10-22-29\n",
      "RatU_Day2NSD_2021-07-24_08-16-38\n",
      "RatV_Day1NSD_2021-10-02_08-10-23\n",
      "RatV_Day3NSD_2021-10-07_08-10-12\n",
      "Roy-maze1\n",
      "Ted-maze1\n",
      "Ted-maze2\n",
      "Ted-maze3\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "from scipy.io import loadmat\n",
    "from scipy.stats import ranksums\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.gridspec import GridSpec\n",
    "import seaborn as sns\n",
    "import h5py\n",
    "from learned_tuning.learned_tuning import calculate_learned_tuning_PBE_subsets, calculate_place_field_fidelity_of_learned_tuning\n",
    "\n",
    "%matplotlib widget\n",
    "\n",
    "\n",
    "data_dir = r'/home/kouroshmaboudi/Documents/Learned_tuning_Python/Datasets'\n",
    "sessions = [d for d in os.listdir(data_dir) if os.path.isdir(os.path.join(data_dir, d))]\n",
    "\n",
    "included_session_IDX = [x for x in range(17) if x not in (12, 13)]\n",
    "# included_session_IDX = np.arange(6, 11)\n",
    "# included_session_IDX = [2]\n",
    "\n",
    "\n",
    "sessions = [sessions[i] for i in included_session_IDX]\n",
    "\n",
    "number_of_sessions = len(sessions)\n",
    "\n",
    "\n",
    "epochs = np.empty((number_of_sessions,), dtype=object)\n",
    "epoch_durations = np.empty((number_of_sessions,), dtype=object)\n",
    "\n",
    "\n",
    "time_bins_centers = np.empty((number_of_sessions,), dtype=object)\n",
    "time_bin_brain_state_2D_array = np.empty((number_of_sessions,), dtype=object)\n",
    "\n",
    "spatial_tunings_maze = np.empty((number_of_sessions,), dtype=object)\n",
    "stable_above_1Hz_PF_unit_index = np.empty((number_of_sessions,), dtype=object)\n",
    "\n",
    "learned_tunings = np.empty((number_of_sessions,), dtype=object)\n",
    "learned_tunings_place_field_corr = np.empty((number_of_sessions,), dtype=object)\n",
    "learned_tunings_place_field_corr_unit_id_shuffle = np.empty((number_of_sessions,), dtype=object)\n",
    "\n",
    "for session_idx, session_name in enumerate(sessions):\n",
    "\n",
    "    print(session_name)\n",
    "\n",
    "    session_dataset_path = os.path.join(data_dir, session_name)\n",
    "    session_number = included_session_IDX[session_idx]\n",
    "\n",
    "    #--------------------------------------------------------------------------------------------\n",
    "    # Load epochs[session_idx] information\n",
    "\n",
    "    filename = f'{session_name}.fileInfo_for_python.mat'\n",
    "    file_path = os.path.join(session_dataset_path, filename)\n",
    "\n",
    "    mat_file = loadmat(file_path)\n",
    "    session_info = mat_file[\"fileInfo\"]\n",
    "\n",
    "    epochs[session_idx] = session_info[\"behavior\"][0][0][0][0][\"time\"]\n",
    "    epoch_durations[session_idx] = epochs[session_idx][:, 1] - epochs[session_idx][:, 0]\n",
    "\n",
    "    epoch_names = ['PRE', 'MAZE', 'POST']\n",
    "   \n",
    "    \n",
    "    #---------------------------------------------------------------------------------------------\n",
    "    # Brain state detection results\n",
    "\n",
    "    if 0<=session_number<=4 or 6<=session_number<=10:\n",
    "        filename = f'{session_name}.brainStateDetection_HMMtheta_EMG_SWS_SchmidtTrigger.mat'\n",
    "        file_path = os.path.join(session_dataset_path, filename)\n",
    "\n",
    "        mat_file = loadmat(file_path)\n",
    "        brainStates_bouts_label = mat_file['brainState']['bouts'][0][0][:, :-1]\n",
    "        bouts_start_end = brainStates_bouts_label[:, :-1]\n",
    "        bout_duration = bouts_start_end[:, 1] - bouts_start_end[:, 0] \n",
    "        bout_labels = brainStates_bouts_label[:, -1].astype(int)\n",
    "\n",
    "        brainStates_names = []\n",
    "        for i in range(4):\n",
    "            brainStates_names.append(mat_file['brainState']['names'][0][0][i][0][0])\n",
    "    \n",
    "    else: # Miyawaki dataset\n",
    "\n",
    "        filename = f'{session_name}.fileInfo_for_python.mat'\n",
    "        file_path = os.path.join(session_dataset_path, filename)\n",
    "\n",
    "        mat_file = loadmat(file_path)\n",
    "        brainStates_bouts_label = mat_file['fileInfo']['brainStates'].item()\n",
    "\n",
    "        bouts_start_end = brainStates_bouts_label[:, :-1]\n",
    "        bout_duration = bouts_start_end[:, 1] - bouts_start_end[:, 0] \n",
    "        bout_labels = brainStates_bouts_label[:, -1].astype(int)\n",
    "\n",
    "        # swapping the 3s and 4s, because the 3s in Hiro's data are QWAKE while in the other datasets they are active wake(WAKE)\n",
    "        bout_labels_temp = bout_labels.copy()\n",
    "        bout_labels_temp[bout_labels == 3] = 4\n",
    "        bout_labels_temp[bout_labels == 4] = 3\n",
    "        bout_labels = bout_labels_temp[:]\n",
    "        del bout_labels_temp\n",
    "\n",
    "\n",
    "    missclassified_state_idx = (np.mean(bouts_start_end, axis=1) > epochs[session_idx][1, 0]) & (np.mean(bouts_start_end, axis=1) < epochs[session_idx][1, 1]) & (np.isin(bout_labels, [1,2]))\n",
    "    bout_labels[missclassified_state_idx] = 4\n",
    "\n",
    "\n",
    "    brainStates_names = ['NREM', 'REM', 'WAKE', 'QWAKE']\n",
    "\n",
    "\n",
    "    unique_state_labels = np.unique(bout_labels)\n",
    "    num_bouts = bouts_start_end.shape[0]\n",
    "\n",
    "    time_bins_centers[session_idx] = np.arange(0, bouts_start_end[-1,1]+1, 0.25)+0.125\n",
    "    time_bins_brain_state = np.full(time_bins_centers[session_idx].shape, np.nan)\n",
    "\n",
    "    for bout_idx, bout_timing in enumerate(bouts_start_end):\n",
    "        inside_bout_idx = np.logical_and(bout_timing[0] < time_bins_centers[session_idx],  time_bins_centers[session_idx] < bout_timing[1]) \n",
    "        time_bins_brain_state[inside_bout_idx] = bout_labels[bout_idx]\n",
    "\n",
    "    # reformatting for imshow later\n",
    "    time_bin_brain_state_2D_array[session_idx] = np.zeros((len(np.unique(bout_labels)), len(time_bins_centers[session_idx])))\n",
    "    for time_bin_index, label in enumerate(time_bins_brain_state):\n",
    "        if ~np.isnan(label):\n",
    "            time_bin_brain_state_2D_array[session_idx][int(label)-1, time_bin_index] = 1\n",
    "\n",
    "\n",
    "\n",
    "    # --- from Bapun detection results to confirm \n",
    "\n",
    "    # filename = f'{session_name}.brainstates.npy'\n",
    "    # file_path = os.path.join(session_dataset_path, filename)\n",
    "    # brain_states_Bapun = np.load(file_path, allow_pickle = True).item()\n",
    "\n",
    "    # bouts_start_bapun = brain_states_Bapun['epochs[session_idx]']['start']/3600\n",
    "    # bouts_end_bapun = brain_states_Bapun['epochs[session_idx]']['stop']/3600\n",
    "\n",
    "    # bout_labels_Bapun = brain_states_Bapun['epochs[session_idx]']['label']\n",
    "\n",
    "    # for i in range(bout_labels_Bapun.shape[0]):\n",
    "    #     if bout_labels_Bapun[i] == 'NREM':\n",
    "    #         bout_labels_Bapun[i] = 1\n",
    "    #     elif bout_labels_Bapun[i] == 'REM':\n",
    "    #         bout_labels_Bapun[i] = 2\n",
    "    #     elif bout_labels_Bapun[i] == 'AW':\n",
    "    #         bout_labels_Bapun[i] = 3\n",
    "    #     elif bout_labels_Bapun[i] == 'QW':\n",
    "    #         bout_labels_Bapun[i] = 4\n",
    "\n",
    "\n",
    "    #-------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    # Load unit stability by recording block data (PRE, POST, latePOST)\n",
    "    \n",
    "    filename = f'{session_name}.cluster_quality_by_block'\n",
    "    file_path = os.path.join(session_dataset_path, filename)\n",
    "\n",
    "    mat_file = loadmat(file_path)\n",
    "    cluster_quality_by_block = mat_file['cluster_quality_by_block'][0]\n",
    "\n",
    "\n",
    "\n",
    "    #----------------------------------------------------------------------------------------------\n",
    "    # Load spike data\n",
    "\n",
    "    filename = f'{session_name}.spikes_for_python.mat'\n",
    "    file_path = os.path.join(session_dataset_path, filename)\n",
    "\n",
    "    mat_file = loadmat(file_path)\n",
    "    spikes_pyr = mat_file[\"spikes_pyr\"]\n",
    "\n",
    "    #### Extracting all place fields from the imported .mat file\n",
    "    spatial_tuning_smoothed = spikes_pyr[\"spatialTuning_smoothed\"]\n",
    "\n",
    "    if session_number in [6, 7]: # RatN and RatS\n",
    "        num_units = spatial_tuning_smoothed.shape[0] # for RatN only\n",
    "    else:\n",
    "        num_units = spatial_tuning_smoothed[0].shape[0]\n",
    "\n",
    "    num_pos_bins = spatial_tuning_smoothed[0][0]['uni'][0][0].size\n",
    "\n",
    "    # print(num_units, num_pos_bins)\n",
    "\n",
    "    spikes = []; # spike data and place field info of each unit\n",
    "\n",
    "    # attributes = list(spikes_pyr.dtype.names) % if we want to work on all variable in the imported .mat data structure\n",
    "    running_directions = {'LR', 'RL', 'uni'}\n",
    "    other_attributes   = {'spike_times', 'shank_id','cluster_id'}\n",
    "\n",
    "    iter = 0\n",
    "    for unit in range(num_units):\n",
    "        \n",
    "        # Create dictionaries for each unit and store the matrices\n",
    "        \n",
    "        unit_spikes = dict()\n",
    "\n",
    "        unit_spikes['place_fields']  = {}\n",
    "        unit_spikes['peak_pos_bins'] = {}\n",
    "        unit_spikes['place_fields_remaze']  = {}\n",
    "        unit_spikes['peak_pos_bins_remaze'] = {}\n",
    "        \n",
    "        for direction in running_directions:\n",
    "            try:\n",
    "                if session_number in [6, 7]:    \n",
    "                    unit_spikes['place_fields'][direction] = spikes_pyr[\"spatialTuning_smoothed\"][unit][0][direction][0][0].reshape(num_pos_bins) \n",
    "                    unit_spikes['peak_pos_bins'][direction] = spikes_pyr['peakPosBin'][unit][0][direction][0][0][0][0]\n",
    "                    # unit_spikes['peak_firing_rate'][direction] = spikes_pyr['peakFR'][unit][0][direction][0][0][0][0]\n",
    "                else:\n",
    "                    unit_spikes['place_fields'][direction] = spikes_pyr[\"spatialTuning_smoothed\"][0][unit][direction][0][0].reshape(num_pos_bins) \n",
    "                    unit_spikes['peak_pos_bins'][direction] = spikes_pyr['peakPosBin'][0][unit][direction][0][0][0][0]\n",
    "                    # unit_spikes['peak_firing_rate'][direction] = spikes_pyr['peakFR'][0][unit][direction][0][0][0][0]\n",
    "\n",
    "                if session_number in [8,9,10]:\n",
    "                    unit_spikes['place_fields_remaze'][direction] = spikes_pyr[\"spatialTuning_smoothed_re\"][0][unit][direction][0][0].reshape(num_pos_bins) \n",
    "                    unit_spikes['peak_pos_bins_remaze'][direction] = spikes_pyr['peakPosBin_re'][0][unit][direction][0][0][0][0]\n",
    "\n",
    "\n",
    "            except ValueError:\n",
    "                if iter == 0:\n",
    "                    print(\"This session has only one running direction\")\n",
    "                iter += 1\n",
    "\n",
    "\n",
    "        if session_number in [9, 10]: # for Rat V sessions\n",
    "            unit_spikes['spike_times'] = spikes_pyr['time'][0][unit]\n",
    "            unit_spikes['shank_id']    = spikes_pyr['id'][0][unit][0][1]\n",
    "            unit_spikes['shank_id']    += 1\n",
    "            unit_spikes['cluster_id']  = spikes_pyr['id'][0][unit][0][0]\n",
    "\n",
    "        elif session_number in [6, 7]: # for RatN and RatS\n",
    "            unit_spikes['spike_times'] = spikes_pyr['time'][unit][0] \n",
    "            unit_spikes['shank_id']    = spikes_pyr['id'][unit][0][0][0]\n",
    "            unit_spikes['cluster_id']  = spikes_pyr['id'][unit][0][0][1]\n",
    "\n",
    "        elif session_number == 8: # RatU  \n",
    "            unit_spikes['spike_times'] = spikes_pyr['time'][0][unit]\n",
    "            unit_spikes['shank_id']    = spikes_pyr['id'][0][unit][0][0] # shank indices already starts at zero\n",
    "            unit_spikes['shank_id']    += 1\n",
    "            unit_spikes['cluster_id']  = spikes_pyr['id'][0][unit][0][1]\n",
    "        else: # Grosmark, Hiro, and all other sessions\n",
    "            unit_spikes['spike_times'] = spikes_pyr['time'][0][unit]\n",
    "            unit_spikes['shank_id']    = spikes_pyr['id'][0][unit][0][0] # need to go one down for the other datasets\n",
    "            unit_spikes['cluster_id']  = spikes_pyr['id'][0][unit][0][1]\n",
    "\n",
    "\n",
    "        #------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "        # Extract the cluster quality information by block for the current unit\n",
    "\n",
    "\n",
    "        curr_unit_idx = np.where(cluster_quality_by_block['cluster_ids'][unit_spikes['shank_id']-1] == unit_spikes['cluster_id'])[0]\n",
    "        \n",
    "        spike_amplitude_by_block = cluster_quality_by_block['spike_amplitude_by_block'][unit_spikes['shank_id']-1][curr_unit_idx]\n",
    "        spike_amplitude_by_block = np.nan_to_num(spike_amplitude_by_block, nan=0)\n",
    "        spike_amplitude_by_block_percent = spike_amplitude_by_block/cluster_quality_by_block['session_mean_spike_amplitude'][unit_spikes['shank_id']-1][curr_unit_idx]# as a percentage of session mean\n",
    "        unit_spikes['spike_amplitude_by_block'] = spike_amplitude_by_block_percent\n",
    "\n",
    "        firing_rate_by_block = cluster_quality_by_block['firing_rate_by_block'][unit_spikes['shank_id']-1][curr_unit_idx]\n",
    "        firing_rate_by_block = np.nan_to_num(firing_rate_by_block, nan=0)\n",
    "        # firing_rate_by_block_percent = firing_rate_by_block/cluster_quality_by_block['session_mean_firing_rate'][unit_spikes['shank_id']][curr_unit_idx]\n",
    "        if firing_rate_by_block.shape[1] == 2: \n",
    "            sleep_firing_rate = (firing_rate_by_block[0][0]*epoch_durations[session_idx][0] + firing_rate_by_block[0][1]*epoch_durations[session_idx][2])/np.sum(epoch_durations[session_idx][[0,2]])\n",
    "        elif firing_rate_by_block.shape[1] == 3:\n",
    "            sleep_firing_rate = (firing_rate_by_block[0][0]*epoch_durations[session_idx][0] + firing_rate_by_block[0][1]*4*3600 + firing_rate_by_block[0][2]*(epoch_durations[session_idx][2]-4*3600))/np.sum(epoch_durations[session_idx][[0,2]])\n",
    "\n",
    "        if sleep_firing_rate > 0:\n",
    "            firing_rate_by_block_percent = firing_rate_by_block/sleep_firing_rate\n",
    "        else:\n",
    "            firing_rate_by_block_percent = np.zeros((len(firing_rate_by_block),))\n",
    "\n",
    "        unit_spikes['firing_rate_by_block'] = firing_rate_by_block_percent                \n",
    "\n",
    "        isolation_distance_by_block = cluster_quality_by_block['isolation_distance_by_block'][unit_spikes['shank_id']-1][curr_unit_idx]\n",
    "        isolation_distance_by_block = np.nan_to_num(isolation_distance_by_block, nan=0)\n",
    "        unit_spikes['isolation_distance_by_block'] = isolation_distance_by_block\n",
    "\n",
    "\n",
    "        try:\n",
    "            unit_spikes['pre_post_unit_stability'] = (\n",
    "                # (unit_spikes['spike_amplitude_by_block'][0] > 0.8) & \n",
    "                (unit_spikes['firing_rate_by_block'][0][:2] > 0.33) & \n",
    "                (unit_spikes['isolation_distance_by_block'][0][:2] > 15)\n",
    "            ).all()\n",
    "        except:\n",
    "            unit_spikes['pre_post_unit_stability'] = np.nan \n",
    "\n",
    "\n",
    "\n",
    "        spikes.append(unit_spikes) \n",
    "\n",
    "\n",
    "\n",
    "    # Spatial tunings\n",
    "\n",
    "    interp_pos_bins = np.linspace(0, num_pos_bins, 200)\n",
    "    num_pos_bins_interp = len(interp_pos_bins)\n",
    "\n",
    "\n",
    "    spatial_tunings_maze[session_idx] = np.zeros((num_units, num_pos_bins))\n",
    "    spatial_tuning_maze_interp = np.zeros((num_units, num_pos_bins_interp))\n",
    "\n",
    "    spatial_tunings_remaze = np.zeros((num_units, num_pos_bins))\n",
    "    \n",
    "    pre_post_unit_stability_curr_session = np.empty((num_units,))\n",
    "\n",
    "    for unit in range(num_units):\n",
    "\n",
    "        spatial_tunings_maze[session_idx][unit] = spikes[unit]['place_fields']['uni']\n",
    "        spatial_tuning_maze_interp[unit] = np.interp(interp_pos_bins, np.arange(1, num_pos_bins+1), spatial_tunings_maze[session_idx][unit])\n",
    "\n",
    "\n",
    "        # reMAZE spatial tunings (all session except RatS with animal's positon on reMAZE recorded)\n",
    "        if session_number in range(8, 11):  # RatU_Day2, RatV_Day1, RatV_day3\n",
    "            spatial_tunings_remaze[unit] = spikes[unit]['place_fields_remaze']['uni']\n",
    "\n",
    "        pre_post_unit_stability_curr_session[unit] = spikes[unit]['pre_post_unit_stability']\n",
    "\n",
    "    \n",
    "    stable_unit_index = pre_post_unit_stability_curr_session == True\n",
    "    above_1Hz_PF_unit_index = np.nanmax(spatial_tuning_maze_interp, axis=1) > 1\n",
    "    \n",
    "    stable_above_1Hz_PF_unit_index[session_idx]  = np.where(np.logical_and(stable_unit_index, above_1Hz_PF_unit_index))[0]\n",
    "   \n",
    "\n",
    "\n",
    "    #--------------------------------------------------------------------------------------------------------------\n",
    "    # Learned tunings during each epochs[session_idx]\n",
    "    \n",
    "    # Load .mat file\n",
    "    mat_file = loadmat(os.path.join(session_dataset_path, session_name + '.assemblyTunings_allPBEs_Lthresh1e_3.mat'))\n",
    "\n",
    "\n",
    "    learned_tunings_curr_session = dict()\n",
    "\n",
    "\n",
    "    # PRE, MAZE, POST\n",
    "    learned_tunings_curr_session['PRE'] = mat_file[\"assemblyTunings\"]['pre'].item()['data'].item()\n",
    "    learned_tunings_curr_session['MAZE'] = mat_file[\"assemblyTunings\"]['run'].item()['data'].item()\n",
    "    learned_tunings_curr_session['POST'] = mat_file[\"assemblyTunings\"]['post'].item()['data'].item()\n",
    "\n",
    "\n",
    "    # late POST\n",
    "    # mat_file = loadmat(os.path.join(session_dataset_path, session_name + '.assemblyTunings_allPBEs_last4hoursPOST.mat'))\n",
    "    # learned_tunings['latePOST'] = mat_file[\"assemblyTunings\"]['post'].item()['data'].item()\n",
    "\n",
    "\n",
    "    # MAZE theta learned tunings\n",
    "    mat_file = loadmat(os.path.join(session_dataset_path, session_name + '.assemblyTunings_activeRun_binDur0.02.mat'))\n",
    "    learned_tunings_curr_session['maze_theta'] = mat_file['learnedTunings']\n",
    "\n",
    "\n",
    "    #REMAZE theta learned tunings\n",
    "    # mat_file = loadmat(os.path.join(session_dataset_path, session_name + '.assemblyTunings_remaze_stricterThetaDetection.mat'))\n",
    "    # learned_tunings['remaze_theta'] = mat_file['learnedTunings']\n",
    "\n",
    "\n",
    "    #-----------------------------------------------------------------------------------------------------------------\n",
    "    # Calculate the LT fidelities\n",
    "\n",
    "    learned_tunings[session_idx] = dict.fromkeys(epoch_names)\n",
    "    learned_tunings_place_field_corr[session_idx] = dict.fromkeys(epoch_names)\n",
    "    learned_tunings_place_field_corr_unit_id_shuffle[session_idx] = dict.fromkeys(epoch_names)\n",
    "    num_shuffles = 10000\n",
    "\n",
    "    for epoch, epoch_name in enumerate(epoch_names):\n",
    "\n",
    "        learned_tunings[session_idx][epoch_name] = np.full((num_units, num_pos_bins_interp), np.nan)\n",
    "\n",
    "        for unit in stable_above_1Hz_PF_unit_index[session_idx]:\n",
    "            curr_unit_learned_tuning = learned_tunings_curr_session[epoch_name][unit].reshape(num_pos_bins)\n",
    "            curr_unit_learned_tuning = np.interp(interp_pos_bins, np.arange(1, num_pos_bins+1), curr_unit_learned_tuning)\n",
    "            curr_unit_learned_tuning[np.isnan(curr_unit_learned_tuning)] = 0\n",
    "\n",
    "            # Normalize\n",
    "            learned_tunings[session_idx][epoch_name][unit] = curr_unit_learned_tuning\n",
    "        \n",
    "\n",
    "        # Calculate the correlation between learned tunings and MAZE place fields\n",
    "\n",
    "        learned_tunings_place_field_corr[session_idx][epoch_name] = np.full((num_units,), np.nan)\n",
    "        learned_tunings_place_field_corr_unit_id_shuffle[session_idx][epoch_name] = np.full((num_units, num_shuffles), np.nan)\n",
    "        \n",
    "        (learned_tunings_place_field_corr[session_idx][epoch_name][stable_above_1Hz_PF_unit_index[session_idx]],\n",
    "        learned_tunings_place_field_corr_unit_id_shuffle[session_idx][epoch_name][stable_above_1Hz_PF_unit_index[session_idx], :],\n",
    "        _) = calculate_place_field_fidelity_of_learned_tuning(\n",
    "                learned_tunings[session_idx][epoch_name][stable_above_1Hz_PF_unit_index[session_idx]],\n",
    "                spatial_tuning_maze_interp[stable_above_1Hz_PF_unit_index[session_idx]],\n",
    "                num_shuffles\n",
    "            )\n",
    "\n",
    "\n",
    "\n",
    "    #-----------------------------------------------------------------------------------------------------------------\n",
    "    # Moving time window learned tunings\n",
    "\n",
    "    # Check if the moving-window LTs have already been calculated\n",
    "\n",
    "    # All offline (NREM + QW) PBEs\n",
    "    offline_LT_calculate_flag = True # start from assuming that we need to calculate the learned tunings based on all offline PBEs (NREM+QW)  \n",
    "    \n",
    "    filename = f'{session_name}.learned_tunings_vs_time_all_offline.npy'\n",
    "    file_path = os.path.join(session_dataset_path, filename)\n",
    "\n",
    "    # But if they already exist and we don't want to recalculate\n",
    "    # all_offline_LT_overwrite_flag = True\n",
    "    all_offline_LT_overwrite_flag = False\n",
    "\n",
    "    if os.path.exists(file_path) and all_offline_LT_overwrite_flag == False:    \n",
    "        learned_tunings_vs_time_all_offline = np.load(file_path, allow_pickle = True).item()\n",
    "        # offline_LT_calculate_flag = False\n",
    "        offline_LT_calculate_flag = False\n",
    "\n",
    "    \n",
    "    #----------------------------------------------------------------------------------------------------------------------\n",
    "    # Moving-window LTs based on exclusively NREM or QW PBEs\n",
    "    NREM_QW_LT_calculate_flag = True\n",
    "    \n",
    "    filename = f'{session_name}.learned_tunings_vs_time_NREM_vs_QW.npy'\n",
    "    file_path = os.path.join(session_dataset_path, filename)\n",
    "\n",
    "    NREM_QW_LT_overwrite_flag = False\n",
    "    if os.path.exists(file_path) and NREM_QW_LT_overwrite_flag == False:\n",
    "\n",
    "        learned_tunings_vs_time_NREM_vs_QW = np.load(file_path, allow_pickle = True).item()\n",
    "\n",
    "        NREM_QW_LT_calculate_flag = False\n",
    "    \n",
    "\n",
    "    if (offline_LT_calculate_flag == True) | (NREM_QW_LT_calculate_flag == True):\n",
    "\n",
    "        # ---------------------------------------------------------------------------------------------------------------------\n",
    "        # Load cluster quality data (L-ratios)\n",
    "        \n",
    "        filename = f'{session_name}.clusterQuality.mat'\n",
    "        file_path = os.path.join(session_dataset_path, filename)\n",
    "\n",
    "        mat_file = loadmat(file_path)\n",
    "\n",
    "        # Access data structure\n",
    "        num_shanks = len(mat_file[\"clusterQuality\"][\"Lratio\"][0])\n",
    "\n",
    "        L_ratios = list()\n",
    "        for shank in range(num_shanks):    \n",
    "            curr_shank_L_ratios = dict()\n",
    "            curr_shank_L_ratios[\"L_ratios\"] = mat_file[\"clusterQuality\"][\"Lratio\"][0][shank]\n",
    "            curr_shank_L_ratios[\"cluster_ids\"] = mat_file[\"clusterQuality\"][\"clus\"][0][shank]\n",
    "            \n",
    "            L_ratios.append(curr_shank_L_ratios)\n",
    "        # L_ratios = []\n",
    "\n",
    "\n",
    "\n",
    "        #-------------------------------------------------------------------------------------------------\n",
    "        # Population Burst Events (PBEs)\n",
    "\n",
    "        overwrite = False # in case we need to read the .mat file again, if there was a change\n",
    "\n",
    "        filename = f'{session_name}.PBEs.pkl'\n",
    "        file_path = os.path.join(session_dataset_path, filename)\n",
    "\n",
    "        if os.path.exists(file_path) and overwrite == False:\n",
    "\n",
    "            # PBEs = np.load(file_path, allow_pickle=True)\n",
    "            PBEs = pd.read_pickle(file_path)\n",
    "        else: # if it doesn't exist then read it from the .mat file\n",
    "\n",
    "            filename = f'{session_name}.PBEInfo_replayScores.mat'\n",
    "            file_path = os.path.join(session_dataset_path, filename)\n",
    "            f = h5py.File(file_path, \"r\")\n",
    "            PBEInfo = f['PBEInfo_replayScores']    \n",
    "        \n",
    "\n",
    "            # Store the population burst events in a pandas DataFrame\n",
    "            num_PBEs = PBEInfo[\"fr_1msbin\"].shape[0]\n",
    "            attributes = list(PBEInfo.keys())\n",
    "\n",
    "            PBEs = pd.DataFrame(columns=[attr for attr in attributes[1:] if attr not in ['posteriorProbMat', 'postMat_nonNorm']])\n",
    "\n",
    "            # Loop over the PBEs and add each one as a row to the DataFrame\n",
    "            num_dots = int(num_PBEs * (10/100))\n",
    "            count = 0\n",
    "\n",
    "            for pbe in range(num_PBEs): #  \n",
    "    \n",
    "                for attr in PBEs.columns:\n",
    "                    ref = PBEInfo[attr][pbe][0]\n",
    "                    obj = f[ref]\n",
    "\n",
    "                    if attr in ['epoch', 'brainState']: # convert the ascii code to string\n",
    "                        arr = np.array(obj).flatten()\n",
    "                        epoch = \"\".join(chr(code) for code in arr)\n",
    "                        PBEs.at[pbe, attr] = epoch\n",
    "                    elif attr in ['fr_1msbin', 'fr_20msbin', 'posteriorProbMat', 'postMat_nonNorm']: # no need to flatten\n",
    "                        arr = np.array(obj)\n",
    "                        PBEs.at[pbe, attr] = arr\n",
    "                    else: \n",
    "                        arr = np.array(obj).flatten()\n",
    "                        PBEs.at[pbe, attr] = arr\n",
    "\n",
    "            if (pbe+1) % num_dots == 1:\n",
    "                count += 1\n",
    "                message = \"Importing PBEs\" + \".\" * count\n",
    "                print(message, end=\"\\r\")\n",
    "\n",
    "            print(\"All PBEs were imported\") \n",
    "        \n",
    "            filename = f'{session_name}.PBEs.pkl'\n",
    "            file_path = os.path.join(session_dataset_path, filename)\n",
    "            PBEs.to_pickle(file_path)\n",
    "\n",
    "        num_PBEs = PBEs.shape[0]\n",
    "\n",
    "\n",
    "        # select_units = np.arange(num_units) # in case we need to filter the units\n",
    "        select_units = stable_above_1Hz_PF_unit_index[session_idx]\n",
    "\n",
    "\n",
    "        #------------------------------------------------------------------------------------------------------\n",
    "        # Learned tunings during Non-REM versus Quiet Wake ripples\n",
    "\n",
    "        # The frequency of PBEs ocurring during NREM ('N') or quiet wake ('W')\n",
    "\n",
    "        PBEs_peak_time = np.zeros((num_PBEs, 1))\n",
    "        brain_state_at_pbe = np.empty((num_PBEs, 1), dtype='str')\n",
    "        # brain_state_first_letter = np.empty((num_PBEs, 1), dtype='str')\n",
    "\n",
    "        for pbe in range(num_PBEs):\n",
    "            PBEs_peak_time[pbe] = PBEs.at[pbe, 'peakT']\n",
    "            brain_state_at_pbe[pbe] = PBEs.at[pbe, 'brainState']\n",
    "            # brain_state_first_letter[pbe]= chr(np.concatenate(PBEs[pbe][\"brainState\"])[0])\n",
    "\n",
    "\n",
    "\n",
    "        # Calculate learned tunings separately for NREM and QW PBEs and calculate thier PF fidleities\n",
    "        time_win_duration = 900 # 15 minutes\n",
    "        step_duration = 300 # 5 minutes\n",
    "\n",
    "        time_bin_duration=0.02\n",
    "        num_PF_shuffles = 10000\n",
    "\n",
    "        if NREM_QW_LT_calculate_flag == True: learned_tunings_vs_time_NREM_vs_QW = {}  # create an empty dictionary to store the results\n",
    "        # if offline_LT_calculate_flag == True: learned_tunings_vs_time_all_offline = {}\n",
    "        \n",
    "        for epoch_idx, epoch in enumerate(epoch_names): \n",
    "                \n",
    "            epoch_duration = epochs[session_idx][epoch_idx,1] - epochs[session_idx][epoch_idx,0]\n",
    "                \n",
    "\n",
    "            # all 0ffline (NREM + QW) PBEs \n",
    "            if_inside_epoch = (PBEs_peak_time >= epochs[session_idx][epoch_idx,0]) & (PBEs_peak_time <= epochs[session_idx][epoch_idx,0]+epoch_duration)\n",
    "            epoch_all_offline_PBEs = PBEs.loc[if_inside_epoch].reset_index(drop=True)\n",
    "            PBEs_peak_time_all_offline = PBEs_peak_time[if_inside_epoch]\n",
    "            num_PBEs_all_offline = len(epoch_all_offline_PBEs)\n",
    "\n",
    "\n",
    "            # NREM PBEs\n",
    "            select_IDX_NREM = np.logical_and(if_inside_epoch, brain_state_at_pbe == 'NREM')\n",
    "            epoch_NREM_PBEs = PBEs.loc[select_IDX_NREM].reset_index(drop=True)\n",
    "            PBEs_peak_time_NREM = PBEs_peak_time[select_IDX_NREM]\n",
    "            num_PBEs_NREM = len(epoch_NREM_PBEs)\n",
    "\n",
    "\n",
    "            # QW PBEs\n",
    "            select_IDX_QW = np.logical_and(if_inside_epoch, brain_state_at_pbe == 'QW')\n",
    "            epoch_QW_PBEs = PBEs.loc[select_IDX_QW].reset_index(drop=True)\n",
    "            PBEs_peak_time_QW = PBEs_peak_time[select_IDX_QW]\n",
    "            num_PBEs_QW = len(epoch_QW_PBEs)\n",
    "\n",
    "\n",
    "            # learned tunings across time\n",
    "\n",
    "            num_time_wins = np.floor((epoch_duration-time_win_duration)/step_duration).astype(int)\n",
    "\n",
    "                \n",
    "            if epoch_idx == 0: # if PRE, aligns the last time window with MAZE start and go backward in time for defining the earlier time windows \n",
    "                win_end_times = epochs[session_idx][epoch_idx, 1] - np.arange(num_time_wins)*step_duration\n",
    "                win_start_times = win_end_times - time_win_duration\n",
    "            else: # if MAZE or POST, align the first time bin with MAZE end\n",
    "                win_start_times = epochs[session_idx][epoch_idx, 0] + np.arange(num_time_wins)*step_duration\n",
    "                win_end_times = win_start_times + time_win_duration\n",
    "            win_centers = win_start_times + time_win_duration/2\n",
    "\n",
    "\n",
    "\n",
    "            # sorting the windows chronologically \n",
    "            sort_indices = np.argsort(win_centers)\n",
    "\n",
    "            win_centers = win_centers[sort_indices]\n",
    "            win_start_times = win_start_times[sort_indices]\n",
    "            win_end_times = win_end_times[sort_indices]\n",
    "\n",
    "\n",
    "            PBEs_indices_per_win_all_offline = [None for _ in range(num_time_wins)]\n",
    "            num_PBEs_per_win_all_offline = []\n",
    "            PBEs_indices_per_win_NREM = [None for _ in range(num_time_wins)]\n",
    "            num_PBEs_per_win_NREM = []\n",
    "            PBEs_indices_per_win_QW = [None for _ in range(num_time_wins)]\n",
    "            num_PBEs_per_win_QW = []\n",
    "            \n",
    "            for win in range(num_time_wins):\n",
    "\n",
    "                PBEs_indices_per_win_all_offline[win] = np.where((PBEs_peak_time_all_offline >= win_start_times[win]) & (PBEs_peak_time_all_offline <= win_end_times[win]))[0]\n",
    "                num_PBEs_per_win_all_offline.append(len(PBEs_indices_per_win_all_offline[win]))\n",
    "\n",
    "                PBEs_indices_per_win_NREM[win] = np.where((PBEs_peak_time_NREM >= win_start_times[win]) & (PBEs_peak_time_NREM <= win_end_times[win]))[0]\n",
    "                num_PBEs_per_win_NREM.append(len(PBEs_indices_per_win_NREM[win]))\n",
    "\n",
    "                PBEs_indices_per_win_QW[win] = np.where((PBEs_peak_time_QW >= win_start_times[win]) & (PBEs_peak_time_QW <= win_end_times[win]))[0]\n",
    "                num_PBEs_per_win_QW.append(len(PBEs_indices_per_win_QW[win]))\n",
    "\n",
    "\n",
    "            #-------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "            # All offline \n",
    "\n",
    "            if offline_LT_calculate_flag == True:\n",
    "                \n",
    "                learned_tunings_all_offline_across_time = learned_tunings_vs_time_all_offline[epoch]['learned_tunings_all_offline_across_time']\n",
    "                print('Calculating the offline learned tunings (NREM+QW) for the current session:')\n",
    "\n",
    "                # initialization\n",
    "                learned_tunings_all_offline_across_time = np.full((num_units, num_pos_bins, num_time_wins), np.nan)\n",
    "                learned_tuning_place_field_pearson_corr_all_offline_across_time = np.full((num_units, num_time_wins), np.nan)\n",
    "                median_LT_PF_pearson_corr_all_offline_across_time = [None for _ in range(num_time_wins)]\n",
    "\n",
    "                if len(epoch_all_offline_PBEs) > 0: # especially for MAZE period we know that there are usually no PBEs present\n",
    "                        \n",
    "                    # Calculate the learned tunings\n",
    "                    print(f\"calculating learned tunings using all offline PBEs in {epoch}\")\n",
    "                    learned_tunings_all_offline_across_time = calculate_learned_tuning_PBE_subsets(epoch_all_offline_PBEs, spikes, PBEs_indices_per_win_all_offline, L_ratios, time_bin_duration)\n",
    "\n",
    "                    # Calculate the PF fidelity of the NREM learned tunings\n",
    "                    for win in range(num_time_wins):\n",
    "                        learned_tuning_place_field_pearson_corr_all_offline_across_time[select_units, win], _, median_LT_PF_pearson_corr_all_offline_across_time[win] = calculate_place_field_fidelity_of_learned_tuning(\n",
    "                            learned_tunings_all_offline_across_time[select_units, :, win], \n",
    "                            spatial_tunings_maze[session_idx][select_units, :], \n",
    "                            num_PF_shuffles)\n",
    "                        \n",
    "\n",
    "                learned_tunings_vs_time_all_offline[epoch] = {\n",
    "                    'learned_tunings_all_offline_across_time': learned_tunings_all_offline_across_time,\n",
    "                    'learned_tuning_place_field_pearson_corr_all_offline_across_time': learned_tuning_place_field_pearson_corr_all_offline_across_time,\n",
    "                    'median_LT_PF_pearson_corr_all_offline_across_time': median_LT_PF_pearson_corr_all_offline_across_time,\n",
    "                    'num_PBEs_per_win_all_offline':num_PBEs_per_win_all_offline,\n",
    "                    'win_centers': win_centers,\n",
    "                    'stable_above_1Hz_PF_unit_index':stable_above_1Hz_PF_unit_index[session_idx]\n",
    "                }\n",
    "                \n",
    "\n",
    "            #-------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "            # NREM and QW exclusive moving window LTs\n",
    "\n",
    "            if NREM_QW_LT_calculate_flag == True:\n",
    "\n",
    "                print('Calculating the learned tunings exclusively based on NREM or QW ripples for the current session:')\n",
    "\n",
    "\n",
    "\n",
    "                #-------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "                # NREM\n",
    "\n",
    "                # initialization\n",
    "                learned_tunings_NREM_across_time = np.full((num_units, num_pos_bins, num_time_wins), np.nan)\n",
    "                learned_tuning_place_field_pearson_corr_NREM_across_time = np.full((num_units, num_time_wins), np.nan)\n",
    "                median_LT_PF_pearson_corr_NREM_across_time = [None for _ in range(num_time_wins)]\n",
    "\n",
    "                if len(epoch_NREM_PBEs) > 0: # especially for MAZE period we know that there are usually no PBEs present\n",
    "                    \n",
    "                    # Calculate the learned tunings\n",
    "                    print(f\"calculating learned tunings using NREM PBEs in {epoch}\")\n",
    "                    learned_tunings_NREM_across_time = calculate_learned_tuning_PBE_subsets(epoch_NREM_PBEs, spikes, PBEs_indices_per_win_NREM, L_ratios, time_bin_duration)\n",
    "\n",
    "                    # Calculate the PF fidelity of the NREM learned tunings\n",
    "                    for win in range(num_time_wins):\n",
    "                        learned_tuning_place_field_pearson_corr_NREM_across_time[select_units, win], median_LT_PF_pearson_corr_NREM_across_time[win] = calculate_place_field_fidelity_of_learned_tuning(\n",
    "                            learned_tunings_NREM_across_time[select_units, :, win], \n",
    "                            spatial_tunings_maze[session_idx][select_units, :], \n",
    "                            num_PF_shuffles)\n",
    "\n",
    "\n",
    "                #-------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "                # QW\n",
    "            \n",
    "                # initialize the objects\n",
    "                learned_tunings_QW_across_time = np.full((num_units, num_pos_bins, num_time_wins), np.nan)\n",
    "                learned_tuning_place_field_pearson_corr_QW_across_time = np.full((num_units, num_time_wins), np.nan)\n",
    "                median_LT_PF_pearson_corr_QW_across_time = [None for _ in range(num_time_wins)]\n",
    "\n",
    "                if len(epoch_QW_PBEs) > 0:\n",
    "\n",
    "                    # Calculate the learned tunings\n",
    "                    print(f\"calculating learned tunings using QW PBEs in {epoch}\")\n",
    "                    learned_tunings_QW_across_time = calculate_learned_tuning_PBE_subsets(epoch_QW_PBEs, spikes, PBEs_indices_per_win_QW, L_ratios, time_bin_duration)\n",
    "                    \n",
    "                    # Calculate the PF fidelity of the QW learned tunings\n",
    "                    for win in range(num_time_wins):\n",
    "                        learned_tuning_place_field_pearson_corr_QW_across_time[select_units, win], median_LT_PF_pearson_corr_QW_across_time[win] = calculate_place_field_fidelity_of_learned_tuning(\n",
    "                            learned_tunings_QW_across_time[select_units, :, win], \n",
    "                            spatial_tunings_maze[session_idx][select_units, :], \n",
    "                            num_PF_shuffles)\n",
    "                        \n",
    "                    learned_tunings_vs_time_NREM_vs_QW[epoch] = {\n",
    "                        'learned_tunings_NREM_across_time': learned_tunings_NREM_across_time,\n",
    "                        'learned_tuning_place_field_pearson_corr_NREM_across_time': learned_tuning_place_field_pearson_corr_NREM_across_time,\n",
    "                        'median_LT_PF_pearson_corr_NREM_across_time': median_LT_PF_pearson_corr_NREM_across_time,\n",
    "                        'num_PBEs_per_win_NREM':num_PBEs_per_win_NREM,\n",
    "                        'learned_tunings_QW_across_time': learned_tunings_QW_across_time,\n",
    "                        'learned_tuning_place_field_pearson_corr_QW_across_time': learned_tuning_place_field_pearson_corr_QW_across_time,\n",
    "                        'median_LT_PF_pearson_corr_QW_across_time': median_LT_PF_pearson_corr_QW_across_time,\n",
    "                        'num_PBEs_per_win_QW':num_PBEs_per_win_QW,\n",
    "                        'win_centers': win_centers\n",
    "                    }\n",
    "\n",
    "\n",
    "\n",
    "    # Store the results in case they were just calculated\n",
    "    \n",
    "    if offline_LT_calculate_flag == True:\n",
    "        filename = f'{session_name}.learned_tunings_vs_time_all_offline.npy'\n",
    "        file_path = os.path.join(session_dataset_path, filename)\n",
    "        np.save(file_path, learned_tunings_vs_time_all_offline)\n",
    "\n",
    "\n",
    "    if NREM_QW_LT_calculate_flag == True:\n",
    "        filename = f'{session_name}.learned_tunings_vs_time_NREM_vs_QW.npy'\n",
    "        file_path = os.path.join(session_dataset_path, filename)\n",
    "        np.save(file_path, learned_tunings_vs_time_NREM_vs_QW)\n",
    "\n",
    "\n",
    "                                        \n",
    "    ### Calculate the LT stabilities: correlation between learned tunings in different time windows\n",
    "\n",
    "    def calculate_moving_time_window_correlations(arr1, arr2):\n",
    "    \n",
    "        # Initialize an empty matrix to store the correlation coefficients\n",
    "        # correlations = np.empty((arr1.shape[1], arr2.shape[1]))\n",
    "        correlations = np.full((arr1.shape[1], arr2.shape[1]), np.nan)\n",
    "\n",
    "        # Find the index of the first non-NaN column\n",
    "        non_nan_columns = ~np.all(np.isnan(arr1), axis=0)\n",
    "        arr1_first_non_nan_column_index = np.argmax(non_nan_columns)\n",
    "\n",
    "        non_nan_columns = ~np.all(np.isnan(arr2), axis=0)\n",
    "        arr2_first_non_nan_column_index = np.argmax(non_nan_columns)\n",
    "\n",
    "\n",
    "        # Loop through each column of the first matrix\n",
    "        for i in range(arr1_first_non_nan_column_index, arr1.shape[1]):\n",
    "            # Select the column of interest from the first matrix\n",
    "            column1 = arr1[:, i]\n",
    "\n",
    "            # Find indices of non-NaN values in column1\n",
    "            valid_indices = np.where(~np.isnan(column1))[0]\n",
    "            \n",
    "            if np.any(column1[valid_indices] > 0): \n",
    "                # Loop through each column of the second matrix and calculate the correlation\n",
    "                for j in range(arr2_first_non_nan_column_index, arr2.shape[1]):\n",
    "                    # Select the column of interest from the second matrix\n",
    "                    column2 = arr2[:, j]\n",
    "\n",
    "                    # Find indices of non-NaN values in column2\n",
    "                    valid_indices2 = np.where(~np.isnan(column2))[0]\n",
    "                    if np.any(column2[valid_indices2] > 0):\n",
    "                        # Find the common indices between column1 and column2\n",
    "                        common_indices = np.intersect1d(valid_indices, valid_indices2)\n",
    "                        # common_indices = np.intersect1d(valid_indices[~np.isnan(column1[valid_indices])], valid_indices2[~np.isnan(column2[valid_indices2])])\n",
    "\n",
    "                        # Calculate the correlation coefficient using the common indices\n",
    "                        corr = np.corrcoef(column1[common_indices], column2[common_indices])[0, 1]\n",
    "                        correlations[i, j] = corr\n",
    "\n",
    "            #         else:\n",
    "            #             correlations[i, j] = np.nan\n",
    "            # else:\n",
    "            #     correlations[i, :] = np.nan\n",
    "\n",
    "        return correlations\n",
    "\n",
    "\n",
    "\n",
    "    filename = f'{session_name}.learned_tunings_stability_similarity.npy'\n",
    "    file_path = os.path.join(session_dataset_path, filename)\n",
    "\n",
    "    LT_stability_overwrite_flag = False\n",
    "    \n",
    "    if os.path.exists(file_path) and LT_stability_overwrite_flag == False:\n",
    "        stability = np.load(file_path, allow_pickle = True).item()\n",
    "        # stability['stable_above_1Hz_units'] =  stable_above_1Hz_PF_unit_index\n",
    "\n",
    "        # np.save(file_path, stability)\n",
    "\n",
    "    else:\n",
    "\n",
    "        # Limiting the POST moving time windows to the ones occurring in the first 4 hours \n",
    "        learned_tunings_vs_time_all_offline_earlyPOST = learned_tunings_vs_time_all_offline.copy()\n",
    "\n",
    "        post_win_time_bin_centers = learned_tunings_vs_time_all_offline['POST']['win_centers']\n",
    "        first_4_time_bins_center_indexes = (post_win_time_bin_centers > epochs[session_idx][2, 0]) & (post_win_time_bin_centers < epochs[session_idx][2, 0]+4*3600)\n",
    "\n",
    "        learned_tunings_vs_time_all_offline_earlyPOST['POST']['learned_tunings_all_offline_across_time'] = learned_tunings_vs_time_all_offline['POST']['learned_tunings_all_offline_across_time'][:, :, first_4_time_bins_center_indexes]\n",
    "        learned_tunings_vs_time_all_offline_earlyPOST['POST']['win_centers'] = learned_tunings_vs_time_all_offline['POST']['win_centers'][first_4_time_bins_center_indexes]\n",
    "\n",
    "\n",
    "        learned_tunings_vs_time_no_overlap = learned_tunings_vs_time_all_offline_earlyPOST.copy()\n",
    "        for epoch in ['PRE', 'MAZE', 'POST']:\n",
    "            learned_tunings_vs_time_no_overlap[epoch] = learned_tunings_vs_time_all_offline_earlyPOST[epoch]['learned_tunings_all_offline_across_time'][:,:, ::3]\n",
    "            \n",
    "        num_epochs = len(epoch_names)\n",
    "        num_shuffles = 1000\n",
    "\n",
    "        epochsXCorr_data = np.full((num_epochs, num_epochs, num_units), np.nan)\n",
    "        epochsXCorr_ui = np.full((num_epochs, num_epochs, num_shuffles), np.nan)\n",
    "        epochsXCorr_zscore = np.full((num_epochs, num_epochs, num_units), np.nan)\n",
    "\n",
    "        for epoch_x_index in range(num_epochs): \n",
    "            epoch_x  = epoch_names[epoch_x_index]\n",
    "\n",
    "            epoch_x_moving_time_window_LT = learned_tunings_vs_time_no_overlap[epoch_x]\n",
    "\n",
    "            for epoch_y_index in range(epoch_x_index, num_epochs):\n",
    "                epoch_y = epoch_names[epoch_y_index]\n",
    "                print(epoch_y)\n",
    "\n",
    "                epoch_y_moving_time_window_LT = learned_tunings_vs_time_no_overlap[epoch_y]\n",
    "\n",
    "                for unit_index in range(num_units):\n",
    "                    \n",
    "                    curr_unit_tuning_epoch_x = np.squeeze(epoch_x_moving_time_window_LT[unit_index, :, :])  # learned tuning in the first epoch\n",
    "                    if (curr_unit_tuning_epoch_x.ndim == 1):\n",
    "                        curr_unit_tuning_epoch_x = curr_unit_tuning_epoch_x.reshape(-1,1)\n",
    "\n",
    "                    num_time_bins_epoch_x = curr_unit_tuning_epoch_x.shape[1]\n",
    "\n",
    "                    curr_unit_tuning_epoch_y = np.squeeze(epoch_y_moving_time_window_LT[unit_index, :, :])  # learned tuning in the second epoch (could be the same as first)\n",
    "                    if (curr_unit_tuning_epoch_y.ndim == 1):\n",
    "                        curr_unit_tuning_epoch_y = curr_unit_tuning_epoch_y.reshape(-1,1)\n",
    "                    num_time_bins_epoch_y = curr_unit_tuning_epoch_y.shape[1]\n",
    "\n",
    "                    moving_window_correlation_mat = calculate_moving_time_window_correlations(curr_unit_tuning_epoch_x, curr_unit_tuning_epoch_y)\n",
    "\n",
    "                    if epoch_y_index == epoch_x_index:\n",
    "                        offDiagonalIdx = ~np.eye(moving_window_correlation_mat.shape[0], dtype=bool)\n",
    "                        moving_window_correlation_mat = moving_window_correlation_mat[offDiagonalIdx]\n",
    "\n",
    "                    epochsXCorr_data[epoch_x_index, epoch_y_index, unit_index] = np.nanmedian(moving_window_correlation_mat)\n",
    "\n",
    "\n",
    "                for inst in range(num_shuffles):\n",
    "                    curr_unit_tuning_epoch_x_shuffle = np.zeros_like(curr_unit_tuning_epoch_x)\n",
    "\n",
    "                    for time_bin_index in range(num_time_bins_epoch_x):\n",
    "                        curr_unit_tuning_epoch_x_shuffle[:, time_bin_index] = epoch_x_moving_time_window_LT[np.random.choice(stable_above_1Hz_PF_unit_index[session_idx]), :, time_bin_index]\n",
    "\n",
    "                    curr_unit_tuning_epoch_y_shuffle = np.zeros_like(curr_unit_tuning_epoch_y)\n",
    "\n",
    "                    for time_bin_index in range(num_time_bins_epoch_y):\n",
    "                        curr_unit_tuning_epoch_y_shuffle[:, time_bin_index] = epoch_y_moving_time_window_LT[np.random.choice(stable_above_1Hz_PF_unit_index[session_idx]), :, time_bin_index]\n",
    "\n",
    "                    corrMat = calculate_moving_time_window_correlations(curr_unit_tuning_epoch_x_shuffle, curr_unit_tuning_epoch_y_shuffle)\n",
    "\n",
    "                    if epoch_y_index == epoch_x_index:\n",
    "                        offDiagonalIdx = ~np.eye(corrMat.shape[0], dtype=bool)\n",
    "                        corrMat = corrMat[offDiagonalIdx]\n",
    "\n",
    "                    epochsXCorr_ui[epoch_x_index, epoch_y_index, inst] = np.nanmedian(corrMat)\n",
    "\n",
    "        # Calculate z-scores\n",
    "        mean_ui = np.nanmean(epochsXCorr_ui, axis=2)\n",
    "        std_ui = np.nanstd(epochsXCorr_ui, axis=2)\n",
    "        epochsXCorr_zscore = (epochsXCorr_data - mean_ui[:, :, np.newaxis]) / std_ui[:, :, np.newaxis]\n",
    "\n",
    "        stability = {\n",
    "            'median_stability':epochsXCorr_data,\n",
    "            'median_stability_unit_id':epochsXCorr_ui,\n",
    "            'z_score':epochsXCorr_zscore,\n",
    "            'epoch_names': epoch_names,\n",
    "            'stable_above_1Hz_units': stable_above_1Hz_PF_unit_index[session_idx]\n",
    "        }\n",
    "\n",
    "        np.save(file_path, stability)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot moving time window LTs for example units belonging to an examples session"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_106557/3275568527.py:59: RuntimeWarning: invalid value encountered in divide\n",
      "  normalized_matrix = matrix / col_max[np.newaxis, :]\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f201d56924aa4f34a83053594bd9b9c7",
       "version_major": 2,
       "version_minor": 0
      },
      "image/png": "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",
      "text/html": [
       "\n",
       "            <div style=\"display: inline-block;\">\n",
       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
       "                    Figure\n",
       "                </div>\n",
       "                <img src='data:image/png;base64,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' width=458.3333333333333/>\n",
       "            </div>\n",
       "        "
      ],
      "text/plain": [
       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "## Grosmark Dataset\n",
    "\n",
    "# sample_session_index = 1 # For the main Figure 3\n",
    "# units_to_plot = np.array([60, 65, 40, 74, 96, 61])-1 # AchillesMaze2\n",
    "\n",
    "# sample_session_index = 0\n",
    "# units_to_plot = np.array([56, 30, 86, 139, 72, 63])-1 # AchillesMaze1\n",
    "\n",
    "# sample_session_index = 4\n",
    "# units_to_plot = np.array([2, 17, 19, 26, 45, 11])-1 # AchillesMaze1\n",
    "\n",
    "\n",
    "## Giri Dataset\n",
    "\n",
    "# sample_session_index = 7 # Rat S\n",
    "# units_to_plot = np.array([29, 44, 43, 70, 74, 59])-1\n",
    "\n",
    "sample_session_index = 6 # Rat N\n",
    "units_to_plot = np.array([33, 39, 52, 51, 60, 49])-1\n",
    "\n",
    "\n",
    "## Miyawaki dataset\n",
    "\n",
    "# sample_session_index = 11 # Roy - MAZE 1\n",
    "# units_to_plot = np.array([34, 35, 42, 45, 65, 67, ])-1 # 69\n",
    "\n",
    "# sample_session_index = 13 # TED - MAZE 2\n",
    "# units_to_plot = np.array([2, 6, 14, 25, 28, 32])-1 # , 38 \n",
    "\n",
    "\n",
    "\n",
    "data_dir = r'/home/kouroshmaboudi/Documents/Learned_tuning_Python/Datasets'\n",
    "sessions = [d for d in os.listdir(data_dir) if os.path.isdir(os.path.join(data_dir, d))]\n",
    "\n",
    "if sample_session_index >= 13:\n",
    "    session_name = sessions[sample_session_index+2]\n",
    "else:\n",
    "    session_name = sessions[sample_session_index]\n",
    "\n",
    "session_dataset_path = os.path.join(data_dir, session_name)\n",
    "\n",
    "filename = f'{session_name}.learned_tunings_vs_time_all_offline.npy'\n",
    "file_path = os.path.join(session_dataset_path, filename)\n",
    "    \n",
    "learned_tunings_vs_time_all_offline = np.load(file_path, allow_pickle = True).item()\n",
    "\n",
    "\n",
    "# ---------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Define functions\n",
    "\n",
    "def max_normalize_columns(matrix):\n",
    "    \"\"\"\n",
    "    Takes a matrix as input and returns a new matrix where each column sums up to one (a probability distribution)\n",
    "    \"\"\"\n",
    "    # calculate the sum of each column\n",
    "    col_max = np.max(matrix, axis=0)\n",
    "    \n",
    "    # divide each element in a column by its sum\n",
    "    normalized_matrix = matrix / col_max[np.newaxis, :]\n",
    "    \n",
    "    return normalized_matrix\n",
    "\n",
    "\n",
    "#-----------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Set up figure colors and style\n",
    "\n",
    "sns.set_style('whitegrid') # Set style and context\n",
    "sns.set_context('paper')\n",
    "\n",
    "custom_params = {\"axes.spines.top\": False, \"axes.spines.right\": False}\n",
    "sns.set_theme(style=\"ticks\", rc=custom_params)\n",
    "\n",
    "plt.rcParams.update({\n",
    "    'font.size':5,\n",
    "    'axes.linewidth':1,\n",
    "    'pdf.fonttype':42,\n",
    "    'ps.fonttype':42,\n",
    "    'axes.labelsize':6,\n",
    "    'axes.titlesize':6,\n",
    "    'xtick.labelsize':5,\n",
    "    'ytick.labelsize':5,\n",
    "    'legend.fontsize':5,\n",
    "    'legend.title_fontsize':6,\n",
    "    'legend.frameon': False,\n",
    "    'legend.markerscale':2,\n",
    "    'xtick.major.size':2,\n",
    "    'ytick.major.size':2\n",
    "})\n",
    "\n",
    "epoch_colors = [\n",
    "    '#005CE9', # PRE\n",
    "    'black', # MAZE\n",
    "    '#DD335D', # POST\n",
    "    ] \n",
    "\n",
    "\n",
    "#-------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Generate the figure\n",
    "\n",
    "# Create figure and subplots\n",
    "# plotheight = 1.08\n",
    "plotheight = 160\n",
    "plotwidth = 330\n",
    "font_size = 6\n",
    "\n",
    "\n",
    "fig = plt.figure()\n",
    "fig.set_size_inches([plotwidth/72, plotheight/72])\n",
    "gs = GridSpec(nrows=5, ncols=5, figure=fig, width_ratios=[1, 0.08, 0.02, 1, 0.08], height_ratios = [.07, .5]+[1]*3, hspace=0.35, wspace=0.03)\n",
    "\n",
    "\n",
    "epochs_time_span_in_hours = epochs[sample_session_index]/3600\n",
    "\n",
    "t_end = learned_tunings_vs_time_all_offline['POST']['win_centers'][-1]/3600\n",
    "\n",
    "\n",
    "#------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Brain state indicator bars\n",
    "\n",
    "ax1 = fig.add_subplot(gs[1, 0])\n",
    "\n",
    "ax1.imshow(time_bin_brain_state_2D_array[sample_session_index], extent = [time_bins_centers[sample_session_index][0]/3600, time_bins_centers[sample_session_index][-1]/3600, 0, 4], interpolation='nearest', cmap='binary', origin='lower')\n",
    "ax1.set_aspect(\"auto\")\n",
    "\n",
    "# ax1.axis('off')\n",
    "ax1.set_xlim([0, t_end])\n",
    "ax1.tick_params(axis='both', which='major', labelsize=5, width=1)\n",
    "ax1.set_yticks(np.array([1,2,3,4])-0.5,  brainStates_names, fontsize= 4)\n",
    "ax1.spines['bottom'].set_visible(False)\n",
    "ax1.spines['left'].set_visible(False)\n",
    "ax1.set_xticks([])\n",
    "ax1.tick_params(axis='both', which='both', length=0, pad=2)\n",
    "\n",
    "\n",
    "#------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Epoch time span indicator bars\n",
    "\n",
    "ax0 = fig.add_subplot(gs[0, 0], sharex = ax1)\n",
    "\n",
    "epochs_time_span_in_hours_including_latePOST = np.concatenate((epochs_time_span_in_hours, np.zeros((1, 2))), axis=0 )\n",
    "epochs_time_span_in_hours_including_latePOST[2,1] = epochs_time_span_in_hours[2,0] + 4\n",
    "epochs_time_span_in_hours_including_latePOST[3,0] = epochs_time_span_in_hours[2,0] + 4\n",
    "epochs_time_span_in_hours_including_latePOST[3,1] = epochs_time_span_in_hours[2,1]\n",
    "\n",
    "for epoch_index, epoch in enumerate(epoch_names):\n",
    "    start,end = epochs_time_span_in_hours_including_latePOST[epoch_index]\n",
    "    ax0.axvspan(start, end-0.02, alpha=0.8, color=epoch_colors[epoch_index], linewidth= 0)\n",
    "    ax0.text(np.mean(epochs_time_span_in_hours_including_latePOST[epoch_index]), 1.3, epoch, fontsize=6, ha='center', color=epoch_colors[epoch_index], alpha=0.8)\n",
    "ax0.axis('off')\n",
    "ax0.set_xlim([0, t_end])\n",
    "\n",
    "\n",
    "#---------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Moving-window LTs \n",
    "\n",
    "num_pos_bins = learned_tunings_vs_time_all_offline[epoch]['learned_tunings_all_offline_across_time'].shape[1]\n",
    "\n",
    "ax_start_index = 2\n",
    "for unit_index, unit in enumerate(units_to_plot):\n",
    "    \n",
    "    #------------------------------------------------------------------------------\n",
    "    # Left panels: Learned tunings in 15 minutes time windows for the current unit\n",
    "    \n",
    "    if unit_index < 3:\n",
    "        ax2 = fig.add_subplot(gs[unit_index + ax_start_index, 0])\n",
    "    else:\n",
    "        ax2 = fig.add_subplot(gs[unit_index-3 + ax_start_index, 3])\n",
    "\n",
    "\n",
    "    for j, epoch in enumerate(epoch_names):\n",
    "\n",
    "        LTs = learned_tunings_vs_time_all_offline[epoch]['learned_tunings_all_offline_across_time'][unit, :, :]\n",
    "        LTs = max_normalize_columns(LTs)\n",
    "        LTs[np.isnan(LTs)] = 0\n",
    "\n",
    "        ax2.imshow(LTs, extent = [epochs_time_span_in_hours[j, 0], epochs_time_span_in_hours[j, 1], 0, num_pos_bins], interpolation='nearest', origin = 'lower', cmap='inferno', label=epoch) \n",
    "\n",
    "\n",
    "    ax2.set_xlim([0, t_end])\n",
    "    # ax2.set_title(f\"unit {unit}\", loc = 'left', fontsize= 5, y=0.75)\n",
    "    ax2.set_title(f\"Unit {unit_index+1}\", loc = 'left', fontsize= 5, y=0.82)\n",
    "\n",
    "    ax2.set_aspect(\"auto\")\n",
    "    \n",
    "    ax2.axvline(x = epochs_time_span_in_hours[1, 0], color='white', linestyle='--', linewidth=0.5)\n",
    "    ax2.axvline(x = epochs_time_span_in_hours[1, 1], color='white', linestyle='--', linewidth=0.5)\n",
    "\n",
    "    ax2.set_xticks(np.arange(0, t_end, 2))\n",
    "    if unit_index in [2,5]:\n",
    "        ax2.set_xlabel('Time (hour)', labelpad=0)\n",
    "    else:\n",
    "        ax2.set_xticklabels('')\n",
    "    \n",
    "    ax2.set_yticks([0, num_pos_bins])\n",
    "    if unit_index < 3:\n",
    "        ax2.set_yticklabels([0, 1])\n",
    "    else:\n",
    "        ax2.set_yticklabels([])\n",
    "\n",
    "    if unit_index == 1:\n",
    "        ax2.set_ylabel('Position (normalized)', fontsize=5, labelpad=0)\n",
    "\n",
    "    ax2.tick_params(axis='both', which='major', labelsize=5, length=2, width=1, pad=1)\n",
    "\n",
    "    #-------------------------------------------------------------------------------------\n",
    "    # Right Panels: MAZE place fields \n",
    "\n",
    "    if unit_index < 3:\n",
    "        ax3 = fig.add_subplot(gs[unit_index + ax_start_index, 1], sharey = ax2)\n",
    "    else:\n",
    "        ax3 = fig.add_subplot(gs[unit_index-3 + ax_start_index, 4], sharey = ax2)\n",
    "\n",
    "    ax3.plot(spatial_tunings_maze[sample_session_index][unit], np.arange(num_pos_bins), color = (0.2, 0.2, 0.2), linewidth=0.75, alpha= 0.9)\n",
    "    x_left = 0\n",
    "    x_right = spatial_tunings_maze[sample_session_index][unit]\n",
    "    \n",
    "    ax3.fill_betweenx(np.arange(num_pos_bins), x_left, x_right, alpha=0.4, color = (0.2, 0.2, 0.2), linewidth=0)\n",
    "\n",
    "    ax3.text(0, num_pos_bins+5, f'{np.amax(spatial_tunings_maze[sample_session_index][unit]):.1f} Hz', fontsize = 4, color = (0.2,0.2,0.2))\n",
    "\n",
    "    ax3.spines['left'].set_visible(False)\n",
    "    ax3.spines['bottom'].set_visible(False)\n",
    "    \n",
    "    ax3.tick_params(axis = 'both', which='both', bottom=False, top = False, left=False, right=False, labelbottom = False, labelleft = False)\n",
    "\n",
    "\n",
    "# Adjust the subplots\n",
    "\n",
    "plt.subplots_adjust(left=0.05, right= 0.99, bottom=0.10, top=0.9, hspace=0.1)\n",
    "\n",
    "\n",
    "\n",
    "plt.subplots_adjust(hspace=0.5)\n",
    "plt.show()\n",
    "\n",
    "\n",
    "filename = f'{session_name}.Figure4_learned_example_learned_tunings_v2.pdf'\n",
    "file_path = os.path.join(session_dataset_path, filename)\n",
    "plt.savefig(file_path, dpi=300)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot the matrix of correlation between moving time window LTs belonging to same or different epochs for the same units"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#-----------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Set up figure colors and style\n",
    "\n",
    "sns.set_style('whitegrid') # Set style and context\n",
    "sns.set_context('paper')\n",
    "\n",
    "custom_params = {\"axes.spines.top\": False, \"axes.spines.right\": False}\n",
    "sns.set_theme(style=\"ticks\", rc=custom_params)\n",
    "\n",
    "plt.rcParams.update({\n",
    "    'font.size':5,\n",
    "    'axes.linewidth':1,\n",
    "    'pdf.fonttype':42,\n",
    "    'ps.fonttype':42,\n",
    "    'axes.labelsize':6,\n",
    "    'axes.titlesize':6,\n",
    "    'xtick.labelsize':5,\n",
    "    'ytick.labelsize':5,\n",
    "    'legend.fontsize':5,\n",
    "    'legend.title_fontsize':6,\n",
    "    'legend.frameon': False,\n",
    "    'legend.markerscale':2,\n",
    "    'xtick.major.size':2,\n",
    "    'ytick.major.size':2\n",
    "})\n",
    "\n",
    "epoch_colors = [\n",
    "    '#005CE9', # PRE\n",
    "    'black', # MAZE\n",
    "    '#DD335D', # POST\n",
    "    ] \n",
    "\n",
    "\n",
    "#-------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Generate the figure\n",
    "\n",
    "# Create figure and subplots\n",
    "plotheight = 45#70\n",
    "plotwidth = 330\n",
    "font_size = 6\n",
    "\n",
    "\n",
    "fig = plt.figure()\n",
    "fig.set_size_inches([plotwidth/72, plotheight/72])\n",
    "gs = GridSpec(nrows=2, ncols=8, figure=fig, width_ratios=[0.05] + [1]*6 + [0.15], height_ratios = [0.04, 1], hspace=0.05, wspace=0.2)\n",
    "\n",
    "\n",
    "for unit_index, unit in enumerate(units_to_plot):\n",
    "\n",
    "    ax0 = fig.add_subplot(gs[1, unit_index+1])\n",
    "\n",
    "    for epoch_x_index in range(num_epochs):\n",
    "        epoch_x  = epoch_names[epoch_x_index]\n",
    "\n",
    "        epoch_x_moving_time_window_LT = learned_tunings_vs_time_all_offline[epoch_x]['learned_tunings_all_offline_across_time']\n",
    "\n",
    "        for epoch_y_index in range(num_epochs):\n",
    "            epoch_y = epoch_names[epoch_y_index]\n",
    "\n",
    "            epoch_y_moving_time_window_LT = learned_tunings_vs_time_all_offline[epoch_y]['learned_tunings_all_offline_across_time']\n",
    "    \n",
    "            curr_unit_tuning_epoch_x = np.squeeze(epoch_x_moving_time_window_LT[unit, :, :])  # learned tuning in the first epoch\n",
    "            if (curr_unit_tuning_epoch_x.ndim == 1):\n",
    "                curr_unit_tuning_epoch_x = curr_unit_tuning_epoch_x.reshape(-1,1)\n",
    "\n",
    "            num_time_bins_epoch_x = curr_unit_tuning_epoch_x.shape[1]\n",
    "\n",
    "            curr_unit_tuning_epoch_y = np.squeeze(epoch_y_moving_time_window_LT[unit, :, :])  # learned tuning in the second epoch (could be the same as first)\n",
    "            if (curr_unit_tuning_epoch_y.ndim == 1):\n",
    "                curr_unit_tuning_epoch_y = curr_unit_tuning_epoch_y.reshape(-1,1)\n",
    "            num_time_bins_epoch_y = curr_unit_tuning_epoch_y.shape[1]\n",
    "\n",
    "            moving_window_correlation_mat = calculate_moving_time_window_correlations(curr_unit_tuning_epoch_y, curr_unit_tuning_epoch_x)\n",
    "\n",
    "            im = ax0.imshow(moving_window_correlation_mat, extent = [epochs_time_span_in_hours[epoch_x_index, 0], epochs_time_span_in_hours[epoch_x_index, 1], epochs_time_span_in_hours[epoch_y_index, 0], epochs_time_span_in_hours[epoch_y_index, 1]], vmin = -1, vmax=1, interpolation='nearest', origin = 'lower', cmap='coolwarm', label=epoch) \n",
    "    \n",
    "    ax0.set_xlim([0, t_end])\n",
    "    ax0.set_ylim([0, t_end])\n",
    "\n",
    "    ax0.axvline(x = epochs_time_span_in_hours[1, 0], color='gray', linestyle='-', linewidth=0.5)\n",
    "    ax0.axvline(x = epochs_time_span_in_hours[1, 1], color='gray', linestyle='-', linewidth=0.5)\n",
    "    ax0.axhline(y = epochs_time_span_in_hours[1, 0], color='gray', linestyle='-', linewidth=0.5)\n",
    "    ax0.axhline(y = epochs_time_span_in_hours[1, 1], color='gray', linestyle='-', linewidth=0.5)\n",
    "\n",
    "    ax0.set_xticks(np.arange(0,t_end,2))\n",
    "    ax0.set_yticks(np.arange(0,t_end,2))\n",
    "    ax0.tick_params(axis='both', which='major', length=1, pad=1, width=1)\n",
    "    ax0.set_title(f\"Unit {unit_index+1}\", loc = 'left', fontsize= 5, y=0.88)\n",
    "    if unit_index > 0:\n",
    "        ax0.set_yticklabels([])\n",
    "\n",
    "    if unit_index == 0:\n",
    "        ax0.set_xlabel('Time (hour)', labelpad=1)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# Add the colorbar\n",
    "cbax = fig.add_subplot(gs[1,-1])\n",
    "cbar = plt.colorbar(ax0.get_images()[0], cax=cbax, orientation='vertical', drawedges= False)\n",
    "cbar.set_label('Pearson correlation\\ncoefficient', fontsize=4, labelpad=1)\n",
    "cbar.set_ticks([-1, 0, 1])\n",
    "cbar.ax.tick_params(length=0, pad=1)\n",
    "cbar.ax.yaxis.set_ticks_position('right')\n",
    "cbar.outline.set_visible(False)\n",
    "cbax.set_aspect(3.5)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# Epoch time span indicator bars\n",
    "ax1 = fig.add_subplot(gs[0, 1], sharex = ax0)\n",
    "\n",
    "for epoch_index, epoch in enumerate(epoch_names):\n",
    "    start,end = epochs_time_span_in_hours_including_latePOST[epoch_index]\n",
    "    ax1.axvspan(start, end, alpha=0.8, color=epoch_colors[epoch_index], linewidth= 0)\n",
    "    \n",
    "ax1.axis('off')\n",
    "ax1.set_xlim([0, t_end])\n",
    "\n",
    "ax2 = fig.add_subplot(gs[1, 0], sharey = ax0)\n",
    "for epoch_index, epoch in enumerate(epoch_names):\n",
    "    start,end = epochs_time_span_in_hours_including_latePOST[epoch_index]\n",
    "    ax2.axhspan(start, end, alpha=0.8, color=epoch_colors[epoch_index], linewidth= 0)\n",
    "\n",
    "\n",
    "# ax2.axis('off')\n",
    "ax2.set_ylim([0, t_end])\n",
    "ax2.spines['left'].set_visible(False)\n",
    "ax2.spines['bottom'].set_visible(False)\n",
    "ax2.set_aspect(2.07)\n",
    "\n",
    "ax2.tick_params(axis = 'both', which='both', bottom=False, top = False, left=False, right=False, labelbottom = False, labelleft = False)\n",
    "\n",
    "ax2.set_ylabel('Time (hour)', labelpad=1)\n",
    "\n",
    "\n",
    "# plt.subplots_adjust(left=0.05, right= 0.93, bottom=0.15, top=0.95, hspace=0.1)\n",
    "plt.subplots_adjust(left=0.05, right= 0.93, bottom=0.2, top=0.88, hspace=0.1)\n",
    "\n",
    "plt.show()\n",
    "\n",
    "filename = f'{session_name}.moving_window_LT_correlation_mat.pdf'\n",
    "file_path = os.path.join(session_dataset_path, filename)\n",
    "plt.savefig(file_path, dpi=300)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot the stability versus shuffle for the example units"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib.ticker import FuncFormatter\n",
    "\n",
    "def format_ticks(x, _):\n",
    "    if x == int(x):\n",
    "        return str(int(x))\n",
    "    else:\n",
    "        return str(x)\n",
    "\n",
    "def get_dataframe(LT_stability_data):\n",
    "\n",
    "    df = pd.DataFrame({\n",
    "        'PRE': LT_stability_data[0,0, :],\n",
    "        'POST': LT_stability_data[2,2, :],\n",
    "        'PRE w/ POST':LT_stability_data[0,2, :]\n",
    "        })\n",
    "    \n",
    "    return df\n",
    "\n",
    "sample_session_index = 1\n",
    "units_to_plot = np.array([60, 65, 40, 74, 96, 61])-1 # AchillesMaze2\n",
    "\n",
    "data_dir = r'/home/kouroshmaboudi/Documents/Learned_tuning_Python/Datasets'\n",
    "sessions = [d for d in os.listdir(data_dir) if os.path.isdir(os.path.join(data_dir, d))]\n",
    "\n",
    "session_name = sessions[sample_session_index]\n",
    "\n",
    "session_dataset_path = os.path.join(data_dir, session_name)\n",
    "\n",
    "filename = f'{session_name}.learned_tunings_stability_similarity.npy'\n",
    "file_path = os.path.join(session_dataset_path, filename)\n",
    "\n",
    "stability = np.load(file_path, allow_pickle = True).item()\n",
    "\n",
    "mean_moving_window_correlations_data = stability['median_stability']\n",
    "mean_moving_window_correlations_ui = stability['median_stability_unit_id']\n",
    "\n",
    "mean_moving_window_correlations_ui = get_dataframe(mean_moving_window_correlations_ui)\n",
    "\n",
    "\n",
    "\n",
    "# Plot\n",
    "\n",
    "def plot_violin(ax, data, color):\n",
    "    alpha = 0.9\n",
    "    vio = sns.violinplot(data=data, cut=0, inner=None, positions = [.5, 1.5, 2.5],  color=color, bw = 0.3, linewidth=0, width= 0.4, capstyle='butt', ax=ax)\n",
    "\n",
    "    ax.grid(axis='y', color=(.8,.8,.8), linewidth=0.5)\n",
    "    for axis in ['left', 'bottom']:\n",
    "        ax.spines[axis].set_linewidth(1)\n",
    "\n",
    "    # vio.legend(loc=\"upper center\", bbox_to_anchor=(0.5, 1.5))\n",
    "    vio.set_title(\"\")\n",
    "\n",
    "\n",
    "\n",
    "#-----------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Set up figure colors and style\n",
    "\n",
    "sns.set_style('whitegrid') # Set style and context\n",
    "sns.set_context('paper')\n",
    "\n",
    "custom_params = {\"axes.spines.top\": False, \"axes.spines.right\": False}\n",
    "sns.set_theme(style=\"ticks\", rc=custom_params)\n",
    "\n",
    "plt.rcParams.update({\n",
    "    'font.size':5,\n",
    "    'axes.linewidth':1,\n",
    "    'pdf.fonttype':42,\n",
    "    'ps.fonttype':42,\n",
    "    'axes.labelsize':6,\n",
    "    'axes.titlesize':6,\n",
    "    'xtick.labelsize':5,\n",
    "    'ytick.labelsize':5,\n",
    "    'legend.fontsize':5,\n",
    "    'legend.title_fontsize':6,\n",
    "    'legend.frameon': False,\n",
    "    'legend.markerscale':2,\n",
    "    'xtick.major.size':2,\n",
    "    'ytick.major.size':2\n",
    "})\n",
    "\n",
    "#-------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Generate the figure\n",
    "\n",
    "\n",
    "plotheight = 70\n",
    "plotwidth = 330\n",
    "font_size = 6\n",
    "\n",
    "\n",
    "fig = plt.figure()\n",
    "fig.set_size_inches([plotwidth/72, plotheight/72])\n",
    "gs = GridSpec(nrows=2, ncols=8, figure=fig, width_ratios=[0.05] + [1]*6 + [0.15], height_ratios = [0.04, 1], hspace=0.05, wspace=0.2)\n",
    "\n",
    "\n",
    "columns_to_plot = ['PRE', 'POST', 'PRE w/ POST']\n",
    "\n",
    "for unit_idx, unit in enumerate(units_to_plot):\n",
    "\n",
    "    ax0 = fig.add_subplot(gs[1, unit_idx+1])\n",
    "\n",
    "    plot_violin(ax0, mean_moving_window_correlations_ui, (.55,.55,.55))\n",
    "    sns.scatterplot(\n",
    "        x = np.arange(3)-.1,\n",
    "        y = [mean_moving_window_correlations_data[0,0, unit], mean_moving_window_correlations_data[2,2, unit], mean_moving_window_correlations_data[0,2, unit]],\n",
    "        color = (.2,.2,.2),\n",
    "        marker = 'o',\n",
    "        edgecolor = None,\n",
    "        linewidth = 0,\n",
    "        s = 5,\n",
    "        alpha= 0.8, \n",
    "        ax = ax0\n",
    "    )\n",
    "\n",
    "    ax0.set_ylim([-0.2, 1])\n",
    "    ax0.set_yticks([0, 0.5, 1])\n",
    "    ax0.yaxis.set_major_formatter(FuncFormatter(format_ticks))\n",
    "\n",
    "    ax0.set_xticklabels(columns_to_plot,rotation=35, ha= 'right')\n",
    "    \n",
    "    ax0.tick_params(axis = 'both', which='major',length=1, pad=1)\n",
    "\n",
    "    if unit_idx > 0:\n",
    "        ax0.set_yticklabels([])\n",
    "\n",
    "    if unit_idx == 0:\n",
    "        ax0.set_ylabel('LT stability', labelpad=1)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "plt.subplots_adjust(left=0.05, right= 0.93, bottom=0.45, top=0.95, hspace=0.1)\n",
    "\n",
    "filename = f'{session_name}.moving_window_LT_stability_data_and_ui_example_units.pdf'\n",
    "file_path = os.path.join(session_dataset_path, filename)\n",
    "plt.savefig(file_path, dpi=300)\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Concatenate LT stability and fidelities across all sessions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# LT fidelities\n",
    "\n",
    "learned_tunings_place_field_corr_sessions_concat = dict.fromkeys(epoch_names)\n",
    "learned_tunings_place_field_corr_unit_id_shuffle_concat = dict.fromkeys(epoch_names)\n",
    "lt_pf_correlation_median_across_all_sessions = dict.fromkeys(epoch_names)\n",
    "lt_pf_correlation_median_across_all_sessions_pvalue = dict.fromkeys(epoch_names)\n",
    "\n",
    "for epoch, epoch_name in enumerate(epoch_names):\n",
    "    # data\n",
    "    temp = []\n",
    "    for session_idx in range(number_of_sessions):\n",
    "        temp.append(learned_tunings_place_field_corr[session_idx][epoch_name][stable_above_1Hz_PF_unit_index[session_idx]])\n",
    "    learned_tunings_place_field_corr_sessions_concat[epoch_name] = np.concatenate(temp, axis = 0)\n",
    "    # learned_tunings_place_field_corr_sessions_concat[epoch_name] = learned_tunings_place_field_corr_sessions_concat[epoch_name][place_fields_sort_idx]\n",
    "\n",
    "    # shuffle\n",
    "    temp = []\n",
    "    for session_idx in range(number_of_sessions):\n",
    "        temp.append(learned_tunings_place_field_corr_unit_id_shuffle[session_idx][epoch_name][stable_above_1Hz_PF_unit_index[session_idx]])\n",
    "    learned_tunings_place_field_corr_unit_id_shuffle_concat[epoch_name] = np.concatenate(temp, axis = 0)\n",
    "    # learned_tunings_place_field_corr_unit_id_shuffle_concat[epoch_name] = learned_tunings_place_field_corr_unit_id_shuffle_concat[epoch_name][place_fields_sort_idx]\n",
    "\n",
    "\n",
    "    # # calculate the p-values of place fidelities\n",
    "    # lt_pf_correlation_median_across_all_sessions[epoch_name] = np.nanmedian(learned_tunings_place_field_corr_sessions_concat[epoch_name])  \n",
    "    # ui_lt_pf_correlation_medians = np.nanmedian(learned_tunings_place_field_corr_unit_id_shuffle_concat[epoch_name], axis = 0)\n",
    "\n",
    "num_units_pooled = learned_tunings_place_field_corr_sessions_concat['PRE'].shape[0]\n",
    "\n",
    "column_names = ['PRE', 'MAZE', 'POST', 'PRE_ui', 'MAZE_ui', 'POST_ui']\n",
    "data_list = []\n",
    "for unit in range(num_units_pooled):\n",
    "    curr_unit_data = [\n",
    "        learned_tunings_place_field_corr_sessions_concat['PRE'][unit],\n",
    "        learned_tunings_place_field_corr_sessions_concat['MAZE'][unit],\n",
    "        learned_tunings_place_field_corr_sessions_concat['POST'][unit],\n",
    "        learned_tunings_place_field_corr_unit_id_shuffle_concat['PRE'][unit],\n",
    "        learned_tunings_place_field_corr_unit_id_shuffle_concat['MAZE'][unit],\n",
    "        learned_tunings_place_field_corr_unit_id_shuffle_concat['POST'][unit]\n",
    "    ]\n",
    "\n",
    "    data_list.append(curr_unit_data)\n",
    "\n",
    "LT_fidelity_df = pd.DataFrame(data_list, columns=column_names)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Achilles_10252013\n",
      "Achilles_11012013\n",
      "Buddy_06272013\n",
      "Cicero_09172014\n",
      "Gatsby_08282013\n",
      "Kevin-maze1\n",
      "RatN_Day2_2019-10-11_03-58-54\n",
      "RatS-Day2-2020-11-27_10-22-29\n",
      "RatU_Day2NSD_2021-07-24_08-16-38\n",
      "RatV_Day1NSD_2021-10-02_08-10-23\n",
      "RatV_Day3NSD_2021-10-07_08-10-12\n",
      "Roy-maze1\n",
      "Ted-maze1\n",
      "Ted-maze2\n",
      "Ted-maze3\n"
     ]
    }
   ],
   "source": [
    "# LT stabilities\n",
    "\n",
    "def get_dataframe(LT_stability_data):\n",
    "\n",
    "    df = pd.DataFrame({\n",
    "        'PRE': LT_stability_data[0,0, :],\n",
    "        'POST': LT_stability_data[2,2, :],\n",
    "        'PRE w/ POST':LT_stability_data[0,2, :]\n",
    "        })\n",
    "    \n",
    "    return df\n",
    "\n",
    "sessions = [d for d in os.listdir(data_dir) if os.path.isdir(os.path.join(data_dir, d))]\n",
    "included_session_IDX = [x for x in range(17) if x not in (12, 13)]\n",
    "\n",
    "sessions = [sessions[i] for i in included_session_IDX]\n",
    "\n",
    "mean_moving_window_correlations_z_sessions_concat = []\n",
    "mean_moving_window_correlations_z_median_sessions_concat = []\n",
    "\n",
    "for session_idx, session_name in enumerate(sessions):\n",
    "\n",
    "    print(session_name)\n",
    "\n",
    "    session_dataset_path = os.path.join(data_dir, session_name)\n",
    "    session_number = included_session_IDX[session_idx]\n",
    "\n",
    "    \n",
    "    filename = f'{session_name}.learned_tunings_stability_similarity.npy'\n",
    "    file_path = os.path.join(session_dataset_path, filename)\n",
    "    \n",
    "    stability = np.load(file_path, allow_pickle = True).item()\n",
    "\n",
    "    stable_above_1Hz_PF_unit_index = stability['stable_above_1Hz_units']\n",
    "    mean_moving_window_correlations_z = stability['z_score'][:, :, stable_above_1Hz_PF_unit_index]\n",
    "\n",
    "    mean_moving_window_correlations_z = get_dataframe(mean_moving_window_correlations_z)\n",
    "    mean_moving_window_correlations_z['session_number'] = np.full((stable_above_1Hz_PF_unit_index.shape[0],), session_number)\n",
    "\n",
    "\n",
    "    mean_moving_window_correlations_z_sessions_concat.append(mean_moving_window_correlations_z) \n",
    "    mean_moving_window_correlations_z_median_sessions_concat.append(np.nanmedian(mean_moving_window_correlations_z, axis= 0))\n",
    "\n",
    "mean_moving_window_correlations_z_sessions_concat = pd.concat(mean_moving_window_correlations_z_sessions_concat, ignore_index = True)\n",
    "mean_moving_window_correlations_z_median_sessions_concat = pd.DataFrame(mean_moving_window_correlations_z_median_sessions_concat, columns = mean_moving_window_correlations_z_sessions_concat.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_dataframe(LT_fidelities_stable_vs_unstable):\n",
    "\n",
    "    epochs = []\n",
    "    stability_statuses = []\n",
    "    LT_fidelities = []\n",
    "    LT_fidelities_ui = []\n",
    "\n",
    "    epoch_names = LT_fidelities_stable_vs_unstable.keys()\n",
    "    for epoch in epoch_names:\n",
    "        for stability_status in ['stable', 'unstable']:\n",
    "            curr_LT_fidelities = LT_fidelities_stable_vs_unstable[epoch][f'{stability_status}_data']\n",
    "            curr_num_units = len(curr_LT_fidelities)\n",
    "\n",
    "            curr_LT_fidelities_ui = LT_fidelities_stable_vs_unstable[epoch][f'{stability_status}_ui']\n",
    "            \n",
    "            LT_fidelities.append(curr_LT_fidelities)\n",
    "            LT_fidelities_ui.append(curr_LT_fidelities_ui)\n",
    "            epochs.append([epoch]*curr_num_units)\n",
    "            stability_statuses.append([stability_status]*curr_num_units)\n",
    "            \n",
    "\n",
    "    LT_fidelities = np.concatenate(LT_fidelities, axis = 0)\n",
    "    LT_fidelities_ui = np.concatenate(LT_fidelities_ui, axis = 0)\n",
    "    epochs = np.concatenate(epochs, axis = 0)\n",
    "    stability_statuses = np.concatenate(stability_statuses, axis = 0)\n",
    "\n",
    "\n",
    "    df = pd.DataFrame({\n",
    "        'epoch': epochs,\n",
    "        'stability_status':stability_statuses,\n",
    "        'LT_fidelity': LT_fidelities,\n",
    "        'LT_fidelity_ui': LT_fidelities_ui\n",
    "    })\n",
    "\n",
    "    return df\n",
    "\n",
    "\n",
    "\n",
    "stability_z_threshold = 2\n",
    "\n",
    "sleep_epoch_names = ['PRE', 'POST']\n",
    "\n",
    "stable_units = dict.fromkeys(sleep_epoch_names)\n",
    "unstable_units = dict.fromkeys(sleep_epoch_names)\n",
    "num_stable_units = dict.fromkeys(sleep_epoch_names)\n",
    "num_unstable_units = dict.fromkeys(sleep_epoch_names)\n",
    "\n",
    "LT_fidelities_stable_vs_unstable = dict.fromkeys(sleep_epoch_names)\n",
    "\n",
    "for epoch_index, epoch in enumerate(sleep_epoch_names):\n",
    "\n",
    "    stable_units[epoch] = []\n",
    "    unstable_units[epoch] = []\n",
    "\n",
    "    LT_fidelities_stable_vs_unstable[epoch] = dict.fromkeys(['stable_data', 'unstable_data', 'stable_ui', 'unstable_ui'])\n",
    "\n",
    "    for session_idx, session_name in enumerate(sessions):\n",
    "        session_number = included_session_IDX[session_idx]\n",
    "        curr_session_unit_index = mean_moving_window_correlations_z_sessions_concat['session_number'] == session_number\n",
    "\n",
    "        stable_units_curr_session = np.where(\n",
    "                (mean_moving_window_correlations_z_sessions_concat[epoch] > stability_z_threshold) &\n",
    "                (curr_session_unit_index == True)\n",
    "        )[0]\n",
    "\n",
    "        unstable_units_curr_session = np.where(\n",
    "                (mean_moving_window_correlations_z_sessions_concat[epoch] <= stability_z_threshold) &\n",
    "                (curr_session_unit_index == True)\n",
    "        )[0]\n",
    "\n",
    "        stable_units[epoch].append(stable_units_curr_session)\n",
    "        unstable_units[epoch].append(unstable_units_curr_session)\n",
    "\n",
    "    stable_units[epoch] = np.concatenate(stable_units[epoch], axis= 0)\n",
    "    unstable_units[epoch] = np.concatenate(unstable_units[epoch], axis= 0)\n",
    "\n",
    "    num_stable_units[epoch] = stable_units[epoch].shape[0]\n",
    "    num_unstable_units[epoch] = unstable_units[epoch].shape[0]\n",
    "\n",
    "\n",
    "    LT_fidelities_stable_vs_unstable[epoch]['stable_data'] = LT_fidelity_df.loc[stable_units[epoch], epoch].values\n",
    "    LT_fidelities_stable_vs_unstable[epoch]['stable_ui'] = LT_fidelity_df.loc[stable_units[epoch], f'{epoch}_ui'].values\n",
    "\n",
    "    LT_fidelities_stable_vs_unstable[epoch]['unstable_data'] = LT_fidelity_df.loc[unstable_units[epoch], epoch].values\n",
    "    LT_fidelities_stable_vs_unstable[epoch]['unstable_ui'] = LT_fidelity_df.loc[unstable_units[epoch], f'{epoch}_ui'].values\n",
    "\n",
    "\n",
    "# aa = LT_fidelities_stable_vs_unstable.copy()\n",
    "LT_fidelities_stability_split =  get_dataframe(LT_fidelities_stable_vs_unstable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'PRE': 289, 'POST': 206}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_unstable_units"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f79ba8179e684c748746cef4a6c24590",
       "version_major": 2,
       "version_minor": 0
      },
      "image/png": "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",
      "text/html": [
       "\n",
       "            <div style=\"display: inline-block;\">\n",
       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
       "                    Figure\n",
       "                </div>\n",
       "                <img src='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAaAAAACKCAYAAADsdp69AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABQvUlEQVR4nO29d3hU5da4fU9PDyG9kwIJLfTekV4EC3pU1FcRxfYpikc9R8XeFY/iEUXeo4IcAYkIKkiR3gmhJJAQQhrppGcymbq/P/LO/AgppExmJrDv6+Iis/fs/ayZWXuv/axnFYkgCAIiIiIiIiI2RmpvAUREREREbk7k9hZARERE5GbDaDRiMpladYxUKkUmk3WQRPZBNEAiIiIiNsRoNDJq1CgKCgpadVxAQAAHDx68oYyQaIBEREREbIjJZKKgoICjR48il7fsFmwwGBg2bBgmk8kqBmjx4sUsW7asRfteeukl3njjDVQqVbvHvZYbxgBVV1ezZMkS1Go1Go2GJ554gokTJ1rt/PHx8dTU1DB//nyrnfN6vPPOOzz//PM4OTnZbEwRERHbIJfLUSgUVjlXfHw8Pj4+jB07lsWLF5Oens7cuXM5f/48H3zwAcuWLUOj0RAYGMiAAQNIS0vjm2++Yc6cOaxdu5by8nLGjx/PhAkTSE9P5+OPPyY/P5933nnHMsYff/xBYmIi1dXVPProo0RERLRb7hsmCOHXX39lzJgxrF69mg0bNjB48GB7i9Ru/vnPf4rGR0REpNUEBQXx8MMPExQURG5uLleuXGHQoEHcfffdDBw4kO7du/Poo48il8vR6/V4e3uzadMmALy8vFiyZAmTJk1iz549lnOuXbsWDw8PvLy8SEpKsoqcN8wMyMnJiWPHjjF16lR8fHzw8PAA4Pnnn6eoqAiDwcAnn3xCUFAQt912G3379uX06dPce++9JCYmkpKSwiOPPMKsWbO4//776dOnD2fPniUmJoZXX3213ljx8fH8/PPPmEwmnnnmGUaMGGHZl5WVxYsvvohCoaBbt2689dZbnD17lg8//BCj0cgtt9zCggULWLt2LfHx8Tg5OfHggw/So0ePBsfdf//9rFixApPJxAsvvEB1dTXe3t589NFHJCYm8s0336BQKMjPz+fDDz8kJibGpt+5iIhI2zEYDFZ7r0KhwGg0AqDRaHB2dgbqZlk6nY4333yTEydO8Mwzz7Bq1SokEglQ9+A+efJkevfuzeOPPw5g2Wf+34yzszNPP/10i2VuCTeMAZozZw7FxcUsWLAAZ2dn3n//fbp168bbb7+Ns7Mzu3btYt26dSxevJjKykoef/xxunTpwujRo9m+fTsKhYJHH32UWbNmATBq1ChefPFFnn/++XrWvrS0lN9//50ff/yR2tpaFi1aVM8AHTt2jFmzZjF//nxLlMvHH3/M8uXL8fT05Mknn2TOnDls3bqV//znP7i7u2Mymdi4cWOD48ysW7eOcePGcc899/Dll1/y+++/ExQUhMFgYNWqVRw8eJD4+HhefvllG3zTIiIi7UEqlRIQEMCwYcNadVxAQABSaeNOqyFDhvDRRx+RkZFhMURX8+mnnyIIAqGhoRYZli9fzqhRo1i3bh0REREWd2BJSQnLli0jNzeXt956yzILmjFjBq+99hpKpZJp06ZZxcskuRETUY8cOcL69ev56KOPePfddzl//jw6nY7u3bvz3nvvcfvttxMfHw/AvHnz2LBhA4Bl+/3338/nn3+Ol5cX33//Pb6+vtTW1lJTU0NcXBxPP/00YWFhwP8zSGaqq6tZsWIFRUVFjBw5krlz5zJixAiio6MBqKio4J133kEQBNavX4/RaGThwoX4+fk1OM48A/rggw+466676NOnD/v27ePkyZOMGDGC3bt389JLL5Gens63337Le++9Z+NvWkREpC2IYdh13DAzoNzcXHx9fVEqlXh7e2MymTh//jxXrlxh7dq17Nq1ix07djQ47tppppnz588zcuRIkpKSePDBB7lw4QIAISEhxMTE8PXXXyORSNDr9fWOk8vlLFmyBKh7Yrj11luJjY3l888/x93dHaPRiFQqRavV8vbbb3Py5ElWrlzJ0qVLGxxnJjw8nLNnz1rcgt26dWsg+w34HCEicsMik8luOGPSFm4YA5Samsqzzz5rWbR/9dVXCQkJobi4mIceeoioqKhWnW/fvn18+eWXxMbG0qdPH4sB6tq1KzNmzGD+/PlIpVJiYmJ45ZVXLMf99ddfrFmzBp1Ox5gxY5BKpTz//PM89dRTmEwmlEolX375JUuXLiU3N5eamhpeeOGFRo8zc9ddd7FkyRJ+++03fHx8WLhwIYmJiVb41kRERETsxw3pgmsvZteXq6urvUURERG5ARFdcHXcMDMgERERkc6A0Whk6NChlJSUtOo4b29vjh071qwRak2C6dW5Q/ZCNECNsHr1anuLICIicoNiMpkoKSnB29u7VceVlJQ0Wgnht99+4/Dhw0ilUlJSUvjiiy/429/+xvr16ykrKyMwMJAFCxag1WpZtmwZWVlZPPXUU5bjz507R3x8PAaDgVGjRjF58mSrfM6WIBogEREH5YsvvsDNzY2MjAyWLl1a78Zz5swZ9u3bh9Fo5JlnngGgqqqKFStWIAgCjz76KLt376aiogIXFxemT59eb9/p06e5cOEC0dHRTJgwwV4f8aanqSCoa2lupSQ/P5+YmBgmT57Mhx9+yNNPP21x77m7u7N161YWLFiAXq/nySefpLq6muXLl9OnTx8Avv/+e0JCQgBISkoSDZCIiEgd9957LytXruS7776zGKChQ4eya9cunn32WdasWUNRURF+fn4cOXKEadOmoVQqOXDgAJmZmSxevJhPP/20wb79+/fTvXv3Ft8ARToGayzBL1y4kPPnz/Pee+9ZasudO3cOuVzOk08+yYkTJyzvbez31uv1PPTQQ7i5ubVbltYiGiAREQdm3bp1eHl5UVtba0kwbOqmJQhCkwbl2n1qtZpHHnmEt99+m/Hjx1tdbpGmkUqleHt7t2kNqLFE1J9++onMzEzkcjmRkZF88MEHzJ8/n+TkZFatWkVZWRlQlyLy5ZdfkpOTw6JFizh79iwACxYs4I033sDb25uoqCjmzZvX/g/ZQqwaBWcu1vnss89y6dIlsrOzMRqNvP766+KTlojNuFH08IsvvuDRRx9ttArxtS64DRs2MG3aNL766isEQeCxxx5j9+7dlJeX4+rqyvTp0+vt27FjB1euXEEmk/Hoo4/a4dPd3IhRcHVY1QD961//wsXFhcjISHbs2MH777/PmjVriI2NtZRtmDBhAsuXLycyMtJSr0hExJqIeigi0jmwmgvuwIEDdO/endraWjQaDV5eXkBdVdarGy8ZDAZuv/12/vWvf1nK04g4Np3pd7KHHq5atYqLFy+26xw3GtHR0SxYsMDq5xS5sbCaATpy5AiVlZVkZGSgUqnw8fEB/l+EhpkVK1Zw++23ExoaKiqUiNWxhx6KNfhERNqG1QyQuY6ZObkpPT2dd955B61Wy7333mutYUREmkXUQxGRzoPVo+Buv/12ALtm14qIiHooIuL43DAdUUVEREREOhdiHpCIiBVpb/WCxMRE1qxZw6pVq8jNzeW7777DZDJxzz33kJOTY9lnbfn0ej0ZGRl89tlnPP/8881Wj9+wYQNZWVkWd6eISFsRDZCIiJVpT/WCWbNmkZCQANQlDpaWlloSF6Ojoy37rCFfWVkZO3fupLy8nJEjRxIXF8ekSZMA0Gq1fPrpp7i5uTF8+HCGDBkCwOHDh4mJiSErK6vdcoiIiC44K5CYmMi///1vy0UrcnNjrl4AdQmHRqOxTdULcnNzmT9/Pvfddx+HDx+2unxvv/02Go2Gu+++m7i4uHrvSU1Npba2luDgYHJzc4mPj+fQoUOcPHmSkydPkpSUhFqttppMIjcn4gzICvTt2xdBENiwYYMl7Ffk5uXuu+9utHqB0Wjkyy+/xGg04ufn12j1goSEBM6cOcOvv/5Knz59+O6771AoFDzwwAP19s2ZM6fRsQsLC/H392+RfPfdd59lFhQdHY2/vz/79+8nPT2dxx9/HCcnJ2pqahg4cCC9evUCYOTIkQBcuXJF7Jcl0m5s3pAuOTmZ22+/nfj4eHr37m3LoTuUw4cPc/r0aUJDQ5k5c6a9xRG5DjeqHmZnZxMWFmZvMUSuQ2vXCrOzs9m6datl7W3jxo3IZDIqKiqYN28ey5Yto1+/fjzwwAOsWrUKnU5H165dKSoqcug1P4ecAe3ZsweVSkVJSQkzZsywFOAzGo2UlJTw119/MWnSpGZnGydPnqS0tNTi0+4Ieaqqqjhz5gw5OTm4uLgAdXXIOkKepmSAOlfNxYsXMZlMltL6Op2Ov/76Cx8fHwYPHkxaWhpFRUX4+vrSrVu3evsOHTqEwWDA1dWVQYMGtUm+m5mPPvqI5ORku8rQu3dvlixZgtFodBh5XnjhBbvK4Oi0Zq0wLCyMxx57jO+//56qqipLT6GAgADkcjkeHh7U1NRgMpnIz8/nlVde4cknnyQ2Ntah1/wc0gABDBkyhIMHD1JTU0NKSgoajYbIyEiCg4OJjY0F6sqp7Nq1C5VKRUREBOHh4QBkZGTg7+9PaWlph8rj5uZGZmYmvXv35tKlSwiCwP79+3F2dqZv375cvHiRoqIihg8fbhV5hgwZwoEDBzhy5IjFAIWHh5OamsqECRM4duwYVVVVuLu7o1QqGT58uKVETHJyMr6+vgAN9lVUVDB9+nTWrVsnGqA24Cg3WpPJhMlkchh5RJpn3bp1uLq6kpeXh7e3NwqFotn2DIcPH8bNzY3w8HDkcjkvvfQS7733HgEBASxdupSdO3eSmJjI6NGjWblyJU5OTpZxzGt+/fr14+6777asUZoxr/nFxMSQm5tLTk4OAQEBJCYm4urqalnzs7bb1WENUEJCAs7Ozmzbto3g4GAGDRpkmWWYKSwsRK/X4+/vT3l5OWVlZXh4eJCTk4NKpSIvLw+dTodSqewweQYMGMCpU6cwmUwYDAZCQkLw8PBg1apVzJ49m4CAALKzs60iT0JCAi4uLhgMhlZX0tVqtYwaNYqtW7fSo0ePevuioqI4ePAgCoWiTXKJiIi0nrvvvpuLFy82cAU3tlYYFxfH559/zqRJk8jLy6OyspJ///vfeHh4cOnSJXbu3Mnly5dZsmQJiYmJSCQSZs6cSXJyskOv+TmsARo0aBByuZyhQ4daZh2+vr54eHhw8eJFiouLGTt2LAqFAp1OR2hoKIGBgQBERkYCUF1dbRXj0xJ5SktLkclkqFQqnJycuOeee+jZs2e9c7RXHrMM12Iymdi3bx8mkwl3d3dOnjzJgAEDSEhIoKSkhKioKLp3786+fftwd3dHEIR6+8xRWDfSWkh7cDQXcEtlmjhxYrNP0LZwS9vzO+pMPP30003ui4uLs0QlZmVlERsbi06n4x//+AdQ15p70qRJeHh4WLw+V7fUGDduHOPGjQNg4sSJ9c7t5eXFvHnzyMrKoqSkhIcffhio8xrNmjULoFFD01E5X1YzQAkJCfz6668UFRUxb948cnJy2tyH5doGWS4uLgwcONDy+s4777T8PXXq1CbPYy3Fbok8u3btIi0tjaCgIIYOHWp1eZprGhYcHExwcLDltVm2W265xbLt2in3tfu6d+/eZtkcCWvpoaO5gFsikyAIGI1G/vzzT7u5pe39Hd1IlJaWMnr06Ca9HTKZjFOnTtG1a1eHOG9bsBig0tJSy5pAVFQU3t7erTrRoEGDGDRoEBUVFXz55ZdUVlZa+rAkJCRY+rAsWrTIiuI7DuaZSWMzFJGW4yh66Ggu4JbKVF5ebne39NXY+jtyVHJycvjqq6/QaDQsW7bMsr05PezatSsHDhygsrKy0f0eHh5tMhIddd62IN+2bRubNm3C2dmZkJAQBEFg7dq11NbWMnfuXKZNm9bik23atIkffviBl156id27dwMN+7CYMSvgjUJ5eTkGg4GamhrLDbSsrIyVK1fy97//3c7StQ9btM1wJD0sLS2ld+/eyGQyunbtilarZd++fXh6euLi4sKpU6dIS0ujT58+qNVqcnNz8fX1pWvXrphMJsts1Dz7sgYtkSk1NRU/Pz+byGSP76gzt28JDQ3l3XffZfHixa06zjxjtDZXnzcnJ4fCwkJCQkIICAjokPGa5PfffxcMBoNwLQaDQfj9998bbL8eer1eePLJJ4UXX3xREARBWLNmjXD8+HHL/qSkJKFHjx5CUlJSq8/tyOzatUv46quvhGeeeUZITk62bK+oqLCjVJ0HUQ/bj06nE1JTU+0thkgzPPvss/VeO4Ierl69Wpg/f77w9NNPC1euXLHp2PIZM2YA8OOPPzJ37lzLAtSuXbsw72sJO3bs4PDhw2g0GmbOnElBQcFN1YfFnP8TGRlJRESEZbuHh4e9ROpUiHrYfsxlf0RE2kJZWRnvv/8+//znP+nSpYtNxrQsWKxatYodO3bw7rvvEhQUxJo1a5gyZUqLTzR58mQmT57cIUJ2BsrLy4G6HJurk0RFWoeoh21HNECOS1lZGcuWLSMpKYmVK1eycOHCVh1fWVlJUlISI0aMaFVAV3MIgkBZWRk6nc6yraCggPfee49//OMfeHp6WmWc5rDcKUNCQnj33Xf5xz/+wYkTJzp84M5MRUUFV65csbxWq9VUV1dbXmdnZ9f7UUVajqiHbcdoNGIwGOwthkgjeHl58eabb7Jjx45WGx+oK4fz1VdfUVRUZDWZ/vzzT5555hl+/vnneg8ueXl5vP/++/XuaR2FxQAJgkBQUBBffvklq1evJi0trcMH76ycOnWKI0eOWF7n5eVRW1treb1+/Xr27t1rD9E6PaIeth29Xi8aoBuUgoICqqurW52A3hSCILBnzx7L62vPe/nyZT755BP0er1VxmsKiwH6+OOPgbokpM8++4wvvviiQwfuzIwbN86StAV1M56dO3ei0WgwGo0cPXq0Xp6NSMsR9bDt6PX6Dr9hiNgHtVqNTqezuPrbS0ZGBrm5ucyePbvJ91y8eJF169ZZZbymkK5YsYIrV67UK+EukUgIDQ3l3//+d4cO3pkxGo388ccfCIJATk4Os2bNwtnZGZlMxoQJE9BoNPYWsVMh6mH70el0ouv3BsVseHJycqxyvv3799OlS5frVj/Zvn17o+kL1kI+ceJEli1bRnp6Oq6uriiVSioqKoiIiODBBx/ssIFbQ0FBAStXruTVV1+1tygWTCYTpaWllJaW1nO/ATg7O7N//37GjBkj9kxpIZ1BDx0dcQZ041JVVQVYxwDpdDoOHz7M+PHj67WBaAxBEDh8+DC33XZbu8dtDHmPHj145513ACxlMWyVBdtSAgICePLJJxts37JlCxMnTrT5TV6j0aDX65k/fz4pKSkYDAY2b97M3LlzOXnyJK6uruTn59OrVy/RALWQzqCH11JRUWGTSKGWYjAYHG4NyGg0XvcmJ9I81wY4tZdDhw5RU1PDhAkTKCsru+77rTXraox6dWMc+YJvTDalUmkpOW5Ljh07RkFBAXK5HB8fH+RyOTNnzkQikeDp6YlWq2XIkCFiY7A24sh6eDWONttwRAOkVqvFXLh2cvbsWcvfWVlZ7TLqRqOR33//nQEDBuDv709ZWRlSqRSZTNbkOa/18FiTTl24LDIy0i5PV+fOnWPcuHHk5+dbqg+rVCpL24Xu3buLuUA3AY6Wc2M0Gq0WJWUtrJWzcjNz8uRJy9+1tbWkpaVZir22lj179lBQUFDPo/T111/XK2ZsSywG6PLly4SEhNhFiLZi87pF/8cdd9xBly5d0Ov1uLq60q1bN3Jzc4mLi0MQBIKDgx3uRtBZ6Ex66GgGyGQyOaRMnRWNRoOzs7NdZRAEgeTkZGJiYjh8+DAAR44caZMBunLlCuvWrWPs2LF069bNsv2xxx7D09OzyX5gISEhvP32222S/3pYDNAnn3xCZWUlU6ZMYfr06Z1i2mwv5fDz8wPgwoULBAQEkJyczPbt2xk/fjxKpZKzZ8/Sv39/tm/fzujRo+nTp49d5OyMdCY9FJrpvWMPHLESgqO5KVvDY489RkBAALfeeiujRo2yy2zuypUrVFVVER0dXc8A3Xfffa1qIKnVavn8889xcXHhnnvuqbfP/ODSlNemIyN6LQZo2bJlVFdXs337dp577jmcnZ2ZM2cOEydObJE7adeuXezevZvS0lLuv/9+UlNT29wPqKXYe3Fz3rx5FBcXk5yc3KBcjMlkQiqVNug+KtI8nUkPHc0AGQwGhzNAjiZPa/jhhx/Iyspi8+bNrFixgj59+jB37tw2u7/agrnywdXeHrVazdmzZ+v1JGsOg8HA8uXLycvL45VXXsHNza1VMnSk4a13RWdlZZGSkoJer6dv375kZGTU67TXHLfccgtvv/027733Hps3byYlJYXXXnuN7t27k5CQYHmfNfsBOYJ/ubGifYcPH8bPz4+BAwfe8H1OOoLOooeOtuCv1+sdLg+os/fHcnd3x8PDA6VSSU1NDT/99BMvvPCCzcY3h19fG2155syZFh0vCAKrVq3i7NmzPPPMM/Vcby3F3d291ce0FIt23HvvvfTq1Ys5c+ZYWr8CrVboFStWcOedd7Jz507g5ugHJJPJ0Gq1ltdqtZrjx48zZMgQS2+gzowt+7B0Jj3MyspyKCNUVFREdXW1Q+mcRqNpUahvS7B1P6BFixahUCiYNWsWK1assDxMvvHGGzaTobKyErlc3mC5ITU1tUXH7969mwMHDvD444/Tt2/fNsnQkWvtFgM0f/78emXv9+zZw/jx4xvNv2mKTz/9lLFjx9K3b182bNgAQH5+PjExMZb3rFixgttvv53Q0NBO3WDqahISEupdZCNGjGD27NmtnuqKdC49LCwsdCgdTklJQSKREB4e3qr1gY6kM3c7XbBgAUOGDLG8PnPmDHFxcSxdutRmMhQWFuLj49Nge25uLmq1utk8Q0EQ2LRpE6NGjWLkyJFtlqEjI+QsLriffvqp3o7169e36kQ//vgj+/btY+vWrWzcuJGYmBjeeecdUlNTGTRokHWkdRCOHDnCf/7zH8vrayN9XF1d0Wq1HD161NaidXo6kx6ae0A5CmZ5HEkue6/Ttodr6xB+++23zb6/pqaGl19+mVdffZXffvvNsv2ll17ilVde4bXXXmvVTF4QBJKSkhp9yBEEoV5+UGMYDAbKysro0aOHpUpGY/+ut5YZFBTUYplbi3z9+vWsW7eOjIwM7rzzTgRBQCqVMnTo0Fad6L777uO+++7rIDEdi4EDB9KrVy+gThHUanWD95SUlFBcXGxr0TotnVEPHS3E2Jwxr1arHaZCQ2fMh2tMFyUSSb1Gk42xfft2pk2bxrhx41i8eLGlYLFKpcJkMuHl5dVgZtrcWmRycjJ5eXncf//9je4/evQow4cPb/J4hUJBSEgId999d732MdfSq1cvZs+e3eR6XWBgYJPHthf5XXfdxV133cXOnTuZNGlShw10I6FUKi1uhaKiInQ6HYmJiURFRVmCEmQyWb2K2SLNI+ph+7g6AKGxByJ7YTAYHMYd2FLMuvjf//63QchycxQWFloeTK82vEuXLkUqlfLDDz+wb98+xo0bd91zGQwG1qxZQ3R0NL179250zScxMZGqqqpmgwTuuususrOzueeee5g6dWqD/WlpacTExDQ7U+3IaE/5Tz/9xN/+9jcSEhLqZdwC/P3vf++wgW8UVq5cSUVFBaGhofXKAl2+fJmoqCg7Sta56Ix6qNPpLOH29ubqemG2aCTWUtRqtc3aO1sL80OQyWTixx9/rLevudm1v78/BQUF9OjRo97s2Kwf3t7eDR4OzGuR1/Lrr7+Sn5/Pm2++2WS0r9Fo5MiRI812AB4wYAAzZsxg/fr1REVF0bNnz3r7pVIpCxcuxM/Pr9EZkLe3N4sXL27y/O1F3r9/fwAmTJjQYYPciKxZs4bJkycTFxfHt99+S1RUFAcPHkSlUjFixAgyMzMZM2aMQ9ycOgOdUQ9ra2vRaDQOUXD2aqNjDt11BPLz8zudATJHRbq4uLTquClTpvDWW2+xa9cuJkyYwEsvvcT777/Pe++9h1arpbKy0lJwtzkuX77M5s2bufXWWwkPD2/2vceOHbtuC/q//e1vZGVl8dVXX/Hhhx82qJ9ZUFBATU1NozPVxgIgrIlcLpdz8eLFTlMA0lHo3bs3MpmM/Px8evbsiaurK3PnzrW4HDQaDXl5eZ2mrIy96Yx6WFVVRXV1tUMYoMrKykb/tjd5eXn06NGjUwUjDB48GI1Gw7Rp01p1nIuLC++9957l9a233grAyy+/3KrzbNiwAR8fH8vxzZGamkpNTU2zxlImk/Hoo4/ywgsvsHv3bqZPn95iWTq6Rpx81apVTe68+st0RMyLg/ZgwIABnDlzhuzsbMLDwy0zHfNTRGpqKgEBAaIBaiGdTQ9NJhM6nc4hGg8KBh3qvEuW1xUVFXaUpj5arRaDwdCpDNCjjz5qua9cvf4hkUj44YcfOnTs8vJyEhMTeeihhxrMSJqqWn3u3DkGDx7c7Hl9fHyIjY3l/PnzrTJAVzeI7AjkjnhxtxSTyWQ3xU5JSSE9PZ28vDwCAgIs/tMzZ87Qq1cvVCoV+fn51NbW2qVlRGejs+mhucSMI0TClW9Zhm/KMYKcYshzDqO6uhqDweAQVQiUSqVDyNEaVq9ebbexU1JSEASh0TI7K1asaHRG0tIZb1vWK811LzsK+dKlS3njjTe444476ll9iUTCzz//3KGDtxeNRmO3ZM/vv/+esLCwevlAAL/99hu33HILf/zxBxMnTuS5554TW0q3gM6mh2YZ7bnGZygvoObEb2gzTyMx6oiuuYBJIqNAFURFRQXe3t52k82Ml5dXp5r9XM3Ro0f56quvKCkpYdOmTbz//vv885//7NAxr1y5gkqlwsXFpV4hV71e32TV6rCwMN58883rnjclJYX58+e3Sp4OXwMyl5XYuHFjhw7UEZj9y7bm6NGjKBQKiouL+frrr9FqtTg5ObF27VoGDRrExo0bqa2tpaSkhCeeeMLm8nVGOpseml0z9pgBGauuUJOwFW1mIs69x9P1kS9Zu/p7VEYNUTVpBGlzqbgUi7e3/QM6HCUfqS189tln/Oc//2HhwoXIZLIWl79pD5WVlcTHxzfqknZxcWH27NkNHnqysrLQ6/XNhrv/9NNPuLm5MWbMmBbLolKpOnxN1jI3LiwsZOXKlWRnZxMWFsbChQs73P/XGhqbPiYnJxMaGmrztgxDhw7F3d2dffv2UVhYSEpKCmPHjsXT0xNXV1fCwsKQy+WcOHGCoKAgsR1DK3B0PTRj7hLZkd0ir8VYU0FN4ja0F47iFDuSrne/ztqz6egSU9BJnaiVOnHSYwgB2jx8j22gsuISrsPmInO330zI3v102oNUKsXJycky27XFw0Z2djYvv/wyzz77bL3tKSkpvPjii40eYzKZyMrKarIs1KlTpzh69CiLFi1q1XJAWFhYh8/wLQboueee48knnyQuLo6zZ8/y3HPPNYiBtxcXL17kv//9L6+++qplW1VVFYWFhWRmZjaIbe9org588PPzs/hJr17cEwSBqqoqkpOTxYTUVuDIeng1Zr+7LUKeTbVqKk9upTp5H+W+MVyMvZM8vQzh2Dn+SL5ATU0NoXo1IU4KAlUKCpyC6RI9Gl83NWUb38G59wRc+k9BorB98V9HWCNrK3feeScLFiwgOzubRYsWMW/evA4dr6SkhHPnzvHAAw80mM0oFIpmA64yMzMbNUAmk4n//ve/BAYG4uTk1CDHLiMjg9ra2kZdpba4r1oMkKurq6Vg3YgRI5qNSmqMnJwcvvrqKzQaDcuWLeO7776zWh+W6OhoXnrppXrbsrKygLovPiMjg7i4OJtGnDW1sCoIAjk5OZanh9aWkrnZcWQ9vBqzAbJ2xJlWbyC/soq8iioKS4pRpR8muPAMFV7d0PW/D++AUEZ4euDr5oJUKuXB4QM4lXiKEwkJXK7Vc7hcjQwJFdmFjLj/Xpx6jkZ9JJ7S9W/gOnQOqughSCS2W7cyJ2l3Rm677TbGjx9PTk4OoaGheHl5deh48fHxuLq6Mnr06FYf21SpnfT0dC5dukR8fDwfffRRo+9JTU1tdCnDFq095OanSzc3N5YsWUKfPn04d+5cq3tAhIaG8u6777J48WJ0Oh0pKSm8//77rFmzhoSEBEuYYFv7sFz7RJCdnQ1gaYXd2qSx9mLO/SgrK+PAgQOMHj0aLy8vBEEgPT2doKAgIiMjSUxMZPz48Q7Ru8iR6Sx6aMZseNpqgLR6AwVV1eRVVJJfUUVRlRqjyYRKLifIzYlupefplnEEl+DuuE1Zirxr4/kYbioVVWWlOMmkRLuqiHZVoTWayK2o4NuDx1Eq5MTFzKR3TDk1xzehObcPtxHzUPh1a+tHbxUFBQX07NmzUwUiLF++vMl9Tz31VIeMmZeXx/79+7n//vvbFDXbVMXxnJwcnJ2dSU1NbTRaLiMjg0WLFhEYGFjvHuvj49OkwbImcvON++rFqREjRrTrpOXl5ZanhY7ow1JTU0NGRoYl+zs/P5+uXbtSWlradqFbSXl5Obm5ufj5+REdHY3BYECr1VJTU0NxcTH5+fkIgsDx48e5ePFipzZAtmg50Nn0MCMjA4PBQHFxMSkpKU3OiPVGE1dqNBSpayiqruFKjQaTIKCQyvB1dcbX1ZkAVxd6+XdBjoDs8mnkyQcxufmgiZtDTZcgrpRqoLTxHj9m///VfYnCtLlECTq8lYNw9XIjNTuHHVfKkMr6M0JfQOTGj8AvGn3MOHDq2JbnBQUFJCcnW+UB0VatL/r16wfAtm3b8PHxIS4ujqSkJAoLCztszL179+Lv78/EiRObfE9AQAC+vr6N6lrv3r0bPUYmkyEIAmFhYY0aKRcXF5ycnBq05B4zZoxN7lny2267zfJCp9NRUlLS7uJzXbp0sfTHsWYfll27dtG3b18yMzORyWScPHmSgIAAKioqmDFjhs2KHlZUVLBt2za6du3K7NmzLdvT0tI4ePAgbm5uLFy4EKPRSJcuXRwiHNbR6Ux6qNVq+euvv5DL5RRq9eiQEBURQWFlNXkVVeRXVFJQVY3BaEIhkxHg4UZYqDfDPNwJ8HBDfs1sQBBMaNOOoU74HamLJ66znkQZ1LLozoqKCqZNnQq1VUjKLiOpLESSp0ei12LSZBHcN4a4//Pl1+h0nMktZFdWLGG5R4k88L94DZxGl4FTkMg7pmfPkSNH8PX17dCKytbG/BD0ww8/WErn3HLLLTzyyCMdNuaFCxd44IEHmpwpymQyvvnmmyb3N3WtmDugpqamtrghnUKhYPz48S16b3uxmNKVK1eyc+dOLl++TEBAAC4uLq1KyCorK2PZsmUkJSXx/fffW/qwaLVa7r33XqsIq1QqUavVpKenA3V1wwoKCkhLS+PChQv07t37uuGI1kClUtGvXz+kUinbtm2rty8gIICJEydanp6cnJzEIIRW0Bn08OLFi5hMJioNRrYUVrJ741buGTeSAHc3AjzdGRgWTICHG4rruJ0EwYQu4xTqhN+QSOW4jbobZWjvFj15CkY9hpLLpO3+nZLcDLRSJ6rknlTL3JAQgQQB10ul3OqdgERfizKsD85+3RgeEcrwiFA0uuEkp56h4NgvOB3bhjBgFj0GjcfdiknTRqMRtVrtUMVRW4PJZGLDhg307t2b5OTkDq0KbTQaKSsraxAkYCYjI4OlS5daImyvZuTIkfWaOF5NWFgYAQEB7Nmzp8UGaOTIkTYLn7d8ku3bt7Nhwwbuv/9+fvjhB55//vlWncjLy+u6yVDtZcyYMWzYsIGsrCzCwsKAuht+QEAAFy9exMfHh48//rjDfZdOTk6MGTOG3NxcS1MotVqNyWTC3d3d4sMNCwujqKioQ2W5murqatLS0ujfvz9JSUltbsFrTxxdD41GI6dPnwbATSZlaBcX/FVy7uwZ1eKZriAI6C+fQ318C4JBh+vgWSgj+l83OMCoLsdQlInhSg4ggGcg5yskqF261z////1faYRiz+6EBwegy0lGeykRhX8EitBeOCudGNx3EEKfgVRfSqRo3zqSz+/jQsgoIqN70y8kEHen9kXNlZeXIwgCJSUldO/e/foHOBifffYZGzZsYN26dYSHh/PZZ5912Fg+Pj48+OCDzRo5iUTCnDlzGiTfz507t9ljpk6dyg8//EBBQUGL2mu3tgZee7AYIHO8vlwu59KlS6SlpdlMiJZiMpkoKiqy+JPz8/Px9PTExcWF/Px8lEolH3zwgc3kCQgIQKlUotPpKCoqwmAw4O7ujlqtJiMjg+jo6A7tp34tFRUVnDt3jtjYWFavXs3ChQuRSqWdqi2Eo+vh6dOnLYu5UomEOI86eQ8ePMjs2bOvO3vR5adRc3wzRnU5rgNnoOo+FIm0CbeKyYih5DKGokyMVSVIXbug8OuGy4CpSORKUlJSUJuan2WlpKQQERGBU9RghMiBGAouoUn8E4mzO6qI/sjcuuIeNRC3bnEEJu8hMmErpfpsfsntTbVERZ9AP/qHBOLh3PqZ0eXLl+v931kwtxGXy+Wt6gfUHqZOnUphYSHz5s1rNPw5IyOD5cuXN7peeb1qMOPGjeOXX37hzz//5MEHH2z2vVFRUbaNJjb/sWjRIrRaLU8//TQfffQRCxYssJkQLSU1NRWZTGYpD3Hq1Cn8/f1JS0vjtttu4/XXX+fNN9+02fRRJpMRGhpKenp6vW6JcrmcwMBAIiMjbVoHKzg42NKv5NZbb2XXrl1ER0d3KgPkyHqYm5vLiRMnLK8FAyABiawuiun48eNNht3ri7NQH9+MsTQXlwHTcYodiUTW0FVsqqlEX5yJoTgbTEZk3sEow/ogdevawLhduHCh3utao4k0tZZoVxXOsrrZVE5ODhqNBmdnZyQSKYrAaBSB0Rgri9FeOomg1aAM74PctxsucZNw6j4U5+NbmJGxBWXcZC4qA/n5VDIanZ7e/2eMurhcP7nUaDRy7tw5oC5EuLCw0CETihvjk08+4eWXX25QlLQji5H26NGDYcOGkZyczL333tvgt3ZxcWkykON6BXEVCgXDhg2zzNybIzY2tuVCWwHL3TE9PZ2RI0cycOBAVqxY4XAlUYxGIydOnKC2thaZTEZxcbEl8VMqlaJQKOjatSu1tbU2Lf8RFBRkWZMC2LNnD0FBQQwYMIDIyEibyXEtffv27ZRuOEfVw7y8PLZt22ZJrBQEqDkjRTCCKtKERA7HD5xE0MPgYYOQyetmJoayfNTHt6AvSMOl3xScpzxWb8FfMBkxluahL8rEWFmM1NkdhV9EXeJoM4EB1dXV5OfnU2M0Uao3UqozcEGtJVujJ1WtpaebE95KGd4KOenp6Q2qccg8fHGJm4RJp0GXnYQ2/SSKgEiUob1xH3sfzr3GUn34Z7pdOETv4bcjCe7HuYJiNp05T7VWR68AXwaEBuHVhDE6depUvRD1ffv2cfvtt3eKcGxzwMQjjzzSou6lLaGmpoa33noLuVzOsGHDGqwLSyQSZs+ezQcffEBGRkar7h0tcfO7urq2KK/H1pUr5AaDAZ1Ox59//sm8efMQBAGj0cjWrVu54447bCpMc5w7d47q6mp27tzJ2LFjKS4uJigoCKgL9SwuLmby5MkkJCQwffp0m4U9BwQEoNVq2bNnD1OnTmXYsGFUVFTg6upKQkICgwYNsokcV6PVavnwww8JDQ0lKSkJHx8fh7/wHVkPz58/z/79++tl9UskIPMSQKibAQl6MNVIOPJ7IhlH8uke0hW38qMoq9PR+Q5BCH0YldED1cVyFHID0poCZOo85FI9cu8QlCGxSN1HN6u31VotWaXlZJdWcPhsMmlXqnCSSQmS6RlMGUO7unPe6EGQSkGl0cQVnYF0tY7kPYcZqzES6dOVSB8vfN1c/18xVaUzTtFDEKIGoS9Ip+bkH0hdPFF264/nrGfRZSRSfWgDMk8/+oy4k/7DB6I3GjlfUMzmM+ep0uro6e/LgNBAurrWPaFfvny53kwR6rL8Dxw4wNixYx0+JWHz5s0MHz6c5cuXExISUm9dpq2h4Nu3b2fatGmMGzeOxYsXWwzQ1flosbGxqFQqzp07Z3UDdPr0acLDw+sVOIW6IqdXf77y8vIWj2sN5Fu2bCE+Pp7U1FQeffRRBEFAoVA0G49uSwRBIC0tjcOHD1NVVUWvXr3w8PCwxOoLgsDgwYMpLi4G6hJU9+/fz8iRIzvc/VVWVsa+fftwd3dn2LBhQN0ThLOzMwMHDmT37t02NUBGo5GMjAxOnDiBWq1GEAQ2btxIUVERsbGxJCcnM3DgQEvfekfCEfXQYDBw+fJlnJ2dmTJlSssO0lQiTduPPH87Lr3H4T7oMYyoqMnLQX05FU1GCZUmFQalNwZFBAaDBAqBc8VIJMWoXJSoXBRInKSU6LUUaTXk16rRygTcXVSEeXkQ5aZAqs9jpEsRrgY13roiXAzV6LVKuqsC0OBGtdyNamd3tG4uGKUCYyNCyFdr2HMhg6JqNQqZlHCvLkT4eNGtqxcqhRxlYHeUgd0xVhShTT+BoK9FGdYXrztfoTZpN+W/foxT92G4DJ5JXHAAccEBGIxGUgqv8FtSKhWaWoKcVeSeTkDZyGL6+fPn8fDwYMCAAdb9oazMc889x9q1a8nPz+fbb7+tt6+tbUMKCwst111T9dXkcjkRERH1PCot4do239eSkZFBRkYG+/bt44UXXmiw31zkFGy/Xie/7bbbuO222zh16pSlLbKjUF1dTXV1NefOnWPo0KEYjUZycnI4d+4ct99+O0ajkc8++4wuXbrg6+uLu7s7Pj4+hIWFUVBQgLOzM15eXh1WUE8ul+Pl5YVcLkej0bBr1y4mTpyIq6sr4eHhPPTQQx0y7tWYo4w2b96MWq22hKDHxsZiMpkwGo2UlJTw5ptv4uTkhEKhwNvbGz8/P4d6EnU0PaytrWXr1q0tTj5UmHSEajIJ1OZTqAogTxWBR3I2wwy/4+7shJNXIG79eiPzbPi9641GcsoqyCwuIyP/CuqCGuRaHb5AF72OOHUlxooqTLpaBKORfKkcZ2dnPAJG4ewfiJOnGyWp6ZRVKOk/OQKloRihIhdTRSFCbQWC0YCwfxU9PLzp1TUYeUQIJldvcnSQWVrO3rRMtAYDvm6uRPh4EendFZ+4SQgW91wCioAoutz2IjUn/6B03eu4DpqFU8/RyGUy+gT50yfIn8zsbH78bSvplWpqjCZ8lDLK9EaiXFQEOdXp5dGjR9HpdAwZMsRh29WPHj2a0aNHM2PGDIYPH26Vc/r7+1NQUECPHj3qzaTN+WhmIiMjOXr0aKvOfb3KCadPn8bV1ZWLFxsmM6ekpPD3v//d8rqpkj4dhWWKEB8fT//+/dm0aRPffvstY8aMabL6akdTUFDA8ePHyc3NBeryLtLS0nB3d6e6uprExES8vLwoKSlBp9NZ3EwajQZ3d3cyMjIs5/Lw8GDQoEF0797d6grv7u7O+PHjSUhIIDc3F39/fzIzM5k0aVKH39y1Wi2pqamkpqaSmJjItm3bGD58OHFxcZb3SKVSPDw8OHr0KNHR0Wzfvp3IyEjKysrw9PQkNjaW2NhYh6pY7Ah6WFtby5YtWygpKWl0v2AAiRzUtVWcrdQxy6mUaH0uZXJPLijDkAtG3LVXqDK68/uFMqbPnkuAvz8SwGA0kldRRWZhAVmFBZRVViA31BKkMBGsMDBdqsPFWQcKA8jkSF08kHuHIPMJQe7ph1ThRFbGJXb9uQNKsqAgC2MNVGfI0dboyLpwmCKlD4IgxUWuAlRIEPDr2oWoEF9k2WVItEeQG9XI0NFNKaOHqxMqLy9qFL7kFVSxPSeLMqMUpVxBeFcvukWEE6wvRZ9yCIVfBKqIAdSc+vP/yvrciaFrOMePHyclJQVvqYB3FxdMgsDFGi2nK2uRgsUAASQmJnL58mVGjhzp0Amq1jI+AFOmTOGtt95i165dTJjQdJuM0NBQfvvtN6qqquoZFr1ej0QiabQjqnkpoinMVQ5kMlmDe+C1RU7NjRZthcUAZWZmAnWZy7/99ht33XWXTQWBuvDHAwcOWCy1+cvKysri0KFD3HnnnVy4cIG8vDwqKirYsmUL8+bNw9nZmYMHD1JUVIRCoaj3JVdXV7N3717Onj3LLbfc0iEFBUNCQjh48CDu7u5UVVV16EVVXl7O2bNnSU1NtZRfqaqqIjY2loSEBGJiYkhPT8fPzw8fHx+cnZ2pqKigV69ePP7445bzVFRUcPToUY4fP0737t2Ji4tziIoN9tZDo9HIn3/+SVlZWaMPLPoroE6S4OyTzQSPU0yRmEiq8maDNowywQWDVIFJkIBEQGoEvamY3YnfIpEr0ZsEJCYJSomAsxSUAsgABEgTJCCRIkhkgAyJRFa3w1SBIFSAkAwCCEjQGXTodXpAggD4VDmh1ElQS+Vk5HmQ41qNRm4k3MWAk9KIq9JItSEfP3cD/m7udHWKBIkTepMcg9ZAbbWGipJKdJdykalrCNMZCEPAIJFTLsg5iIoKqQKTSom7azkBsjyCXcPootJRvP4zinRyLjlFYVK4IEjAeEWC1A16uDrhrZDjLm/4PRYXF/Prr78SGBhIv379bFL63564uLi0yH3n5ubGli1bWLt2bYN9Fy5caDSf6nrBBQMGDGDTpk3s3bu3WeMHdHj/n2uxGCCdTsePP/6Ir68v0LD4Z0djMpnQ6XRMnDixgd+/X79+nDx5kjlz5rBr1y6mT59OSkoKv/zyCx4eHhQUFBAdHU1oaGiz6xsVFRVUVlbi4WHd+le+vr5oNBpKSkqoqanpkNyf2tpaKisr60rvh4bWqzA8bdo0vv/+e0t7ij59+tC3b1927tzJ+fPncXFxITAwkBEjRrBjx45GKzNUVVWh1+vx8PCweWHXq7G3HhoMBubMmdPk/szTeWxNO4Cr4IZEkJKncSexqh8qlTPuRiO1WhNak4BWEDBKZSgUUtyVMpRSUMkkgBGJVIJMrgCVCqWzMwqVM3KFHLlChlImRamQI5dLkUtkyE0gNYLUKCDoTEj0AvnZeVSUlCMRQIIEk0wCMpAJUtyR42lQ4aSXotRIMJjAaBJQI+HgBSM6StBTjFEqYFSCQWVC5izBxVWCuyt4eyrw6+JMsLuELuiIEXSotOUYa7XodUYKNRIulcH+PCnVWlCZgohzqWK48RRq114USfuRW6AmbGBXYiaEQiOh5o2Rl5eHUqmka9eudm/hfeLECUvR2urqapt2XRYEgdmzZ1uWFsykpKSwePHiBh1RZTIZX3/9dbPnjIyMZNy4caxevZpu3brVSxm5FnPpHlth+aU//PBDjh07ZsnDMOeT2IoLFy6wd+/eJl1XWq2WV199lbS0NMuazzvvvENgYCAJCQkMHDiQkydPcuDAgSbHEASByMhIJk+ebFXZpVIpAwcOxNPTky5dunRIG9v4+Phme7/7+/szb9480tPTKSgoYM2aNVRWVhIVFUVBQQHV1dVs3LiR/fv3N3uBK5VKHnroIbutD9lbD/fv38+lS5ea3C+YoEYONUYvTir7sVdTTaJLOX2cdLhJFfhKBKIw4mPUI8OEYJKgk6gwyl3oP2w0JokKvcaAXmdArzWg0+rR6ozoqvTotAYMJgNGkxYdAloZCHJJ3T+lFJRSBJWEgq5G8oVajBKh7p8P6CpAMAokudQgkUroK3OumzGZAAGc5AqiggJw1klw04NMZ0KmB0mtEV2VEWOpEYPBSL7BxGWjieOCCZNEhiBxwihzAgVI5AI1phok1OCi1OIhr8VJpiVFqydFoiKiOhEf+WFSlIHkpdagzNGTIvEEaTgmZy9kLShs7ubmxrhx4+zawuHzzz+35Ps88cQTHZb70xhmD445COfq7ebI0Ktnik0VJ72WBx54gJycHD755BPeeOONJr0dtg5QskgeFhZmKW8DNFlbqDVcL/b9aszVoxsrRVFUVMS6detwdnamX79+eHh44O7uTmZmJp6enoSEhODr68uuXbsYMGBAs9PI/Pz8dn+uxjDnAwUHN142v71ERkZy+vTpRg3Dtm3b6N+/PwEBARZFnT9/PpmZmRQVFZGfn8/GjRvx9vZmwIABzbo6oqKi7BqcYG09bI0OQt3v2NhirRkngxq9VIFOrwS60E1QEFwrZaCbGpMgpxYVWkFFicQDo0mGYAQE6OreFZ1ejkwu4ObtgspVWffPRVHvb6ns+m6osrKyBm0g6q4duFxZhVQiIcSz/t1ebzQSFBKK1mBAazBSq9ej0eqp0Wj/7389NVodNRodtRot6kottTU6dNU6DGo9+mo9pfklUAsYXakU3Kg21ZX9EQAkAuckJvxV5UzySyPQqZSCGjd2FIQRXeGJs7dA8IjrpwLU1NSwbds2brvttg55kHN0QkNDkUgknD59ukUPyi1N7lUqlTz33HO8/vrrfPbZZ7z22msNvAsymczm3Zs7dK7bWOx7U31Y+vXrh4+PT6P9X0wmk6UESnV1NX379mXChAnk5OSQn5/PwIED8fb2ZuLEiU32xYC6ZK+Omk6b3W4dle3dr18/YmNj603LzRQVFXHXXXfRo0cPy1NSVVUVHh4eTJ48mcrKSj7++GNqamoYO3Zssxe2rRchO5qW5F9cjblidlNuSOmpzUik5zFFDIMu3Ug+ZiA3pQb3iABcvZxQOMtROMvq/neSo3CWU1FVTmRkpNXWH93d3dm0aRNarbbJ9yRd83rmzJm4qpS4qtpW9drc4fdq97XRZKJGo6WqqpaqSg0lhVVkXShg/3435rgdwFUmoa+TC7VaJUEDw3n00ZZ7Hq5uL2Fr0tLSeOaZZywpIOa/JRIJ//rXvzp0bE9PT4YPH84vv/zC0KFDr5tU35oqJ56enjzzzDO88cYb/PLLLw3WV+3RV02+evVq7r///g45eXOx7431YVEqlaSlpZGVlUVtba1l+8mTJ/Hz86NLly5UVFSwc+dOcnJykEqlhIeHc/jwYaDu5pmZmdngR5HJZJYGcXq93lKi35qYQ56rq6ubfYJuDwkJCY1GZhUXF7NgwQImTZrElStXuHjxIl26dLHUqhs9ejTr1q1j4MCBfPrpp03WevLw8Gg08scWfVg6Sg+vl3/RmB4ajUb++usvampqGrzf1ViDyhRIaXo1cBGTAYRQCRc1RdBIRRSZTEa/fv0oKSlpMqquLQQGBrZYz9zd3amtrW23XhYVFXH69OnrVoX2GurMUdMYvHXFDOxaQJo6DJ3pAv/+d8vq+gUEBNC3b98GM3Fb9QP6+eefbTJOU9x777384x//4JtvvmHJkiVNeiQkEomle3BL6datG7Nnz2bLli1MmjSp3r6xY8e2Wea2It+xY0eHGaDGYt+v14clJibGklCZlJREQUEBkZGRqFQqJBIJSqWSsrIyTCYTgiBY/J+CILBjxw6CgoIs29zd3enduzexsbFt6jLYWo4dO0afPn2anYW1B39/f7Zs2dJgLUgqlWIymfDy8kKlUnHo0CFmzpyJXC6nW7duqFQqdu/eTW5uLqmpqfVcXGZcXV2ZOXNmh7cdboqO0sPr5V80pYfdu3dn3759DdaDtPIuaLnKdSAHXBsf28vLi4kTJ1oCKqxJWFgYhYWF160DBjBx4kSrrKlER0fj4+PDnj176n2XjaGXulAgDwfArRUxP5GRkdxyyy12rdxhMpn45ptvKCwsJCIigscee8ym0WFdunThscce4+OPP2bv3r1N9uYZO3ZsmzwuM2bMYOvWrezevdvSyM7d3d0u+XfywsJCSzvka2nvAnBLY9+vRSaTER0dTXR0NMXFxaxevZrLly9TWFhIjx496pLwPDzYv3+/JdlUIpEwatQoPDw88PHxYcCAAURERNg0tNPNza1Do7bc3d2544472L17tyVcGepusrfeeis6nQ6JRMLChQu5dOkSmZmZ9OrVC4PBgL+/PxcvXmxQigPqipjecsstdo1+6yg9bKsOOjk5MWXKFEsKQGtabyuVSgYOHEjfvn077EaqVCoZNmwYe/bsafZ94eHhVl3Q79GjB0FBQVRUVDSqS21FIpGgUqnw9/e3e4L0iy++yP/8z//QvXt3Tpw4weuvv87nn39uUxn69evH8OHDiY+PZ/To0Q32Ozs7M2/evDad28nJiUGDBnHy5EmLARowYIBdog/lUqkUV1fXBtNqayhBS2Pfm8PX15fnnnuOdevWUVZWRnl5OcnJyYwYMYJBgwbVS6IMCQlh+PDhRERE2FyJf//9d0pKSjp8XJVKxdSpUyktLUWj0WAwGPj2228ZP348lZWVrFu3jkWLFjF27FjWrVtHREQExcXFxMTEEBwcTEhIiGWGJpPJcHJywsfHx+4XfUfpYXt1MDw8nJCQEJKTkzlx4sR1cy5iY2MZOnSoTYx5TEwM58+fb7Jag0wma7WLpiW4ubnh7OzMuXPnSExMbNRV2VKkUik9evRg8ODBNg13bg65XG4pvRQREcGWLVvsIsfs2bM5cuQIZ86caaBP06ZNa1fR5T59+nDw4EGLN8Ve5bnkPj4+jTY0+t///V/bS9MMd999N4IgkJ6ezv79+9Fqtbi4uHDp0iUUCgW33norgwYNslsOQUxMjM3aHkgkEry9vTEajZbkNLN/f+TIkaSkpHD27FmKiooIDAzEzc0NtVrN6dOn+fnnnxk8eDCDBw+mV69eds+5MOPIeiiTyYiLiyMqKordu3c3Wi/L3d2diRMn2jSzXyKRMGbMGDZu3NjousyAAQM6rDK8TCajb9++9OrViwsXLpCYmNhsmsC1yOVyevbsSb9+/RzG8JgxBx4A9QIRgA4PQriasLAwgoODOXr0aIPZe3tbZptnPklJSZax7IHcXITuWg4cOMDDDz9sY3GaRyKRWJq8mWsWFRUV4e7u3mgTJ1tiqwXSq5HJZPTs2RN/f3/Wr18P1M2QSktL+euvv7jzzjuBuoiioqIi9u7dS0hICDNmzLBpo7yW0Bn00NXVlRkzZrB//37Onz9v2e7t7c2sWbPsUtLIx8eHPn36WDrzmvHw8LCJT9+sgzExMaSmpnL06NF6AUSN0bNnT4YMGWJXl29z2DsI4WqGDRvGH3/8wahRoyzbgoKC2r0m5eXlRUREBMePH0cmk9ntt5Dbo+ROe3Fzc7M8Ndk6c9cR6dq1K2FhYWRnZwN1RtkcoqtWq/nzzz+ZMWMGU6ZMsRgsR6Oz6KFUKmXMmDFUVlaSm5uLSqVixowZdq2nN3jwYNLS0urd+G1RDf5qpFIpPXv2JDw8nO3bt1NQUNDgPUqlksmTJ9s1ybQldFQuX1sYMWIE8fHxnDx50rLNWg+7Q4cOZd26dXYtgST///6//6+Bn10QhAbdFkUcmylTpnD06FHOnj1LbGysJZ/F1dWV2tpaBEFg5MiRjB7dfM8Ze9GZ9FAqlTJ8+HA2btxIv379cHVtIgzORqhUKgYOHMihQ4eAuhDt8PBwu8ji4uLCzJkz2bp1K3l5eZbtSqWS2bNnd0hE4I1MQEAA0dHRlt8WaLQeXFsYPHgw69ats+v9QG6vitci1sVkMhEXF4e7uzuHDh2qp1Q9e/bEaDS2KgrM1nQ2PfT19cXDw8Nh2p337NmThIQEtFotAwYMsOtNRaFQMGXKFDZs2GDpVTNhwgTR+LSRYcOG1YsQvbrifXswu+HtOgNypOmmSNs4deoUq1evplevXjz88MOkpKRQWlpq2T9mzBjuueceO0p4fTqjHkZGRlq9sG1bUSgUREVFkZmZ2WSisS1xcnJi6NCh7N69m5CQkGYLYIo0T//+/S0GKCQkxKo5SV5eXu2KYmwvjhECJdIuevfuzSuvvGJJIr311lvrlWlRKpUO35K7M2LNfjHWICQkBL1e7zBtDSIjI9m7d6/VXEaOzu+//86RI0fQ6/UsXbrUsi54+fJlnnrqKeLi4hg1ahRTp061HNNUSairuXrN1trh0k888QQHDx7Ez8/PqudtKaIBugFQKBT1Khg4OTnZpPKDiGPh7e3dqlDojkahUODr6+vQTeesyV9//cUnn3zC7t272b59e722Hi4uLtTW1rZppn+1O9Xa0bbmppT2wjEelURERNrN1dGhjkJgYGCjBYZvZIKCgupFAQYHB7N27VreeOMNVqxYUe+9175uCrMRcgT3qjURZ0AiIjcIMpnM4Rb6/fz8HDLq0pps2rSJ5ORkiouLgbqWL1e7zcyfvz2h+k5OTkilUofNnWorVjNAZ86c4X//938JCQlhyZIlACxbtgy1Wo2LiwvPPfectYYSEWkUUQfpsMoHbcUR2rx3NHPnzmXu3Lls2bKF119/ndraWl577TW2bt2Ki4sLrq6u/PLLL9TW1ra5v1V4eDjFxcU33Fqu1QxQXFwcS5Ys4aeffgLqngIMBgOvvPIKH3zwAfn5+QQGBrZo0U1EpC20VAehZYu/Iu3H0QxiRzJ79ux6FT2mT59u+dvc4rutLFq0iL/++uuGa9LXJgOUmprKp59+Wm/bRx99VO91QUGB5WI3+0SvXoxsrA+LiGNijzJD18MaOgiiHnYmHFEPbYW3tzf9+/e/4dyZbTJAMTExfP311w22Xx2B4+/vz65du4C6J1Fz86Pr9WEREWkJ7dFBEPVQpPPhaOt71sBqLriMjAyWL19Oeno64eHhzJs3D6lUynvvvYdSqbQ8eZrzU9LT0601tIgNiIyMtGu9s5bQUh0EUQ87K51BD1tDa/UwNze3I8VpEdb8DSTC9frrWpnNmzfzwgsv2HJIESsQHx9vKeF+IyDqYedE1EP7Y83fwOYGqLS0lAMHDhASEiL63jsRN9qTp6iHnRNRD+1Pp54BiYiIiIiIgFgJQURERETETogGqA1oNBr2799vbzHqsW3btkZbRYvcmIg6KNIWHE1vOoUBysnJITk52d5iAHDixAlefPFFS/dRe3swz507x6JFi9BqtZ2ypUFnwJH0D0QdvBnoCJ1zNL2BTmCA4uPj+f777/Hw8LD7F/bbb7/x1Vdf0a1bN8aNGwdg18SwpKQk1q9fj1qtJioqColEgtFotJs8NyKOpH8g6uDNQEfonKPpjRmHDkLYs2cPu3bt4u9//zvp6elUVFRYvjxbcuHCBc6cOUOfPn2IiIjgyJEjlJeXM2TIEIKCgmwuT2FhIevXr6dPnz5MmDCB3Nxcli1bxmuvvYaHhwcmk8lhesJ0ZhxF/0DUwZsFa+uco+nNtTikhhw5coRDhw4xdOhQ/P39+fe//82ePXsYNWpUvTLntuDw4cOsXr2a/v37Ex0djUqlonfv3mi1WpKSktBoNDaVJyUlhTfeeINJkyZZWmwHBwczbNgwPv/8c8C+LXZvBBxJ/0DUwZuBjtA5R9ObxnAoLdHr9bzzzjscOXKEjRs3UlhYyKRJk5DL5dx5552sW7eOP/74A51O1+GyGAwGoC673s/Pj6qqKj766CM2bNiATCYjNjYWlUqFUqnscFkAy2eWy+UMHjyYvLw83n77bVasWEFtbS3z5s0jKCgIjUbjEK6izogj6R+IOngz0BE652h60xwO44JLSEjg0qVLbN68mc8//5zVq1fj5ubGww8/zHfffUd6ejo9e/bk3nvv7XBZdu7cSVJSEkFBQcyZM4dNmzYhk8kYPnw4W7duZdasWTbt8njq1Cl++uknhgwZQkFBAdOmTeP48ePMnj2bTz/9lGHDhjFlyhSbyXMj4kj6B6IO3gx0hM45mt5cD4eYAcXHx/PDDz8QEBBARUUFr732GjU1NXh5efHNN9/g7OzME0880eEXv9FoZMOGDZw9e5YHH3yQwsJCtm7dyt13383MmTM5ePAgly9ftmmHx/3797NhwwYeeughpk6daolg+dvf/saOHTtQKpX07NnTZvLciDiK/oGogzcL1tY5R9SblmD3GZDJZOKnn36iS5cuSCQStFotrq6uCILAlClTKC0tpWvXrh0uR0JCAqmpqRw5coQlS5YQFhaGVqvln//8J8888wwpKSkUFxfb7An48uXLeHl5sX//frp3705UVBRQF0p54cIF+vXrR0pKCnfccYdN5LlRcRT9A1EHbxasrXOOpjetwe4zIKlUyvTp07l8+TKHDh1iypQpREZGUlFRwZUrV2xy8cfHx7N69WrCwsI4d+4cxcXF6HQ6VCoV3bp1w2QyMXnyZJv9gJs3b+add97h119/5ciRI6xfv96y79y5cwQHB9O7d2/Lhe8gXtROiSPoH4g6eDNhTZ1zNL1pLXafAZk5f/48SUlJDB8+nODgYEwmE3K51bpFNMnVTyNKpZJTp04RFRVFaWkpZWVleHp68sgjj9gsZv63335j27ZtLF++nA0bNjBx4kS+/fZbgoODyczMJCgoiHvuueeGKsjoCNhL/0DUwZuV9uqco+lNW3AYAyQIAlu3bqVnz55ERETYdOyysjLWr19Pbm4uL7/8MjKZjMOHD9OlSxf69etnExmqq6txc3PDZDLxyiuv4OnpiZOTE0899RR6vZ7Kykqys7MtrX0FQXBoxeps2FP/QNTBmxFr6Jwj6E17cBgDBPZVaPPTyODBg212AzJ/3hMnTiAIAkOGDAHqkse++OILli1bhlwux2Aw2Oxp/GbG3jdUUQdvPqyhc/bQG2th9zWgq7HnxR8bG4urq6tNZTCP5ezszIEDByzbe/ToweDBg1m2bBmAeOHbCHs/zYs6ePNhjd/aHnpjLRxqBmRvbP0ELAgCK1eu5IEHHmDjxo2Eh4czevRoy/7c3FyxuONNhqiDIm3B3rP3tiIaIDtx+PBh3N3dKSoqwt3dHRcXF2pqahgyZAhGoxGZTAZ0XsUScXxEHRSxNw7lgrsZMBgMnDt3jtTUVP773/9SVFSEWq3GycmJxMREAMuFD/Z3C4nceIg6KOIoiAbIBuj1eqAuW/n8+fNs376d3NxcunfvTm1tLa+++ipRUVFUVlaSlZVlZ2lFbkREHRRxREQXXAezd+9eCgsLue2221AoFABkZWXx2Wef4ebmxrPPPsulS5cYMmQIOp3OIQoEitxYiDoo4qiIBqiD0Ol0fP311+h0Op544glqa2vx8vKy7N+3bx+ZmZncfvvtuLm5AaKvXcS6iDoo4uiIBqgD0Gg0VFZW8tVXX/E///M/HDhwAGdnZ+bOnVvPty4i0lGIOijSGRDXgKzM6tWrefvtt1EqlUyYMIFvvvkGuVzOHXfcwYEDBygtLa33ftH+i1gbUQdFOguiAbISarWapUuXUltby5QpU/jjjz8YN24cMTExODk58frrr5Ofn9+g0KDo7hCxFqIOinQ2RBecFdi3bx9VVVW4ubmRlZXF6dOncXJyYtSoUSgUCi5evMiQIUMsNbRERKyNqIMinRHRALWD8vJyPvroIyIiIrh06RJjx44lOzsbrVbL008/zaZNm/D09GTUqFFiZJFIhyDqoEhnRizw1A4uXbqEv78/s2fPZsuWLURHRxMUFMTJkydJS0tjzpw5FveGGF0k0hGIOijSmRENUDvo168f2dnZfPjhh/Tv35/o6Giqq6sxGo0EBgbWu9jFC1+kIxB1UKQzI7rg2kllZSVbtmyhb9++xMXF2VsckZsQUQdFOitiFFw78fDwIDY2lsuXL6PRaOwtjshNiKiDIp0VcQZkBUTfuoi9EXVQpDMizoCswNWLvCIi9kDUQZHOyP8PrLqQCQfwpAAAAAAASUVORK5CYII=' width=416.6666666666667/>\n",
       "            </div>\n",
       "        "
      ],
      "text/plain": [
       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from scipy.stats import wilcoxon, ranksums\n",
    "from matplotlib.ticker import FuncFormatter\n",
    "\n",
    "\n",
    "\n",
    "def get_pval_statement(pvalue):\n",
    "    if pvalue < 0.0001:\n",
    "        pvalue_statement = 'P<1e-4'\n",
    "    else:\n",
    "        pvalue_statement = f'P={pvalue:.4f}'\n",
    "    return pvalue_statement\n",
    "\n",
    "def format_ticks(x, _):\n",
    "    if x == int(x):\n",
    "        return str(int(x))\n",
    "    else:\n",
    "        return str(x)\n",
    "\n",
    "def plot_violin(ax, data, color):\n",
    "    alpha = 0.9\n",
    "    vio = sns.violinplot(data=data, cut=0, inner='quartiles', ax=ax, color=color, bw = 0.25, linewidth=0, width= 0.75, capstyle='butt')\n",
    "\n",
    "    for violin, curr_alpha in zip(ax.collections[::1], [alpha] * 6):\n",
    "        violin.set_alpha(curr_alpha)\n",
    "    for l in ax.lines:\n",
    "        l.set_linestyle('-')\n",
    "        l.set_linewidth(0.5)\n",
    "        l.set_color('white')\n",
    "        l.set_alpha(1)\n",
    "    for l in ax.lines[1::3]:\n",
    "        l.set_linestyle('-')\n",
    "        l.set_linewidth(.75)\n",
    "        l.set_color('white')\n",
    "        l.set_alpha(1)\n",
    "    ax.grid(axis='y', color=(.8,.8,.8), linewidth=0.5)\n",
    "    for axis in ['left', 'bottom']:\n",
    "        ax.spines[axis].set_linewidth(1)\n",
    "\n",
    "    # vio.legend(loc=\"upper center\", bbox_to_anchor=(0.5, 1.5))\n",
    "    vio.set_title(\"\")\n",
    "\n",
    "def plot_violin2(ax, data, color):\n",
    "    alpha = 0.8\n",
    "\n",
    "    vio = sns.violinplot(data = data, x = 'epoch', y = 'LT_fidelity', hue = 'stability_status', color = color, hue_order = ['unstable', 'stable'], split=True, bw = 0.2, cut=0, inner='quartiles', capstyle='butt', ax = ax2)\n",
    "\n",
    "    for violin, curr_alpha in zip(ax.collections[::2], [alpha] * 4):\n",
    "        violin.set_alpha(curr_alpha)\n",
    "\n",
    "    for l in ax.lines: # quartile lines\n",
    "        l.set_linestyle('-')\n",
    "        l.set_linewidth(0.75)\n",
    "\n",
    "    for l in ax.lines[1::3]: # median lines\n",
    "        l.set_linestyle('-')\n",
    "        l.set_linewidth(1)\n",
    "\n",
    "    for i, l in enumerate(ax.lines):\n",
    "        if i % 6 < 3: \n",
    "            l.set_color('black')\n",
    "        else: \n",
    "            l.set_color('white')\n",
    "\n",
    "    # ax.grid(axis='y', color='gray', linewidth=1)\n",
    "    for axis in ['left', 'bottom']:\n",
    "        ax.spines[axis].set_linewidth(1)\n",
    "\n",
    "    violin_elements = vio.collections\n",
    "    for i, elem in enumerate(violin_elements):\n",
    "        if i % 2 == 0:  # Even indices (left side of the violin)\n",
    "            elem.set_facecolor(\"none\")  # Empty fill\n",
    "            elem.set_edgecolor(color)  # Outline color\n",
    "            elem.set_linewidth(1)\n",
    "        else:  # Odd indices (right side of the violin)\n",
    "            elem.set_facecolor(color)  # Filled with the same color\n",
    "            elem.set_edgecolor(\"none\")\n",
    "\n",
    "    vio.legend(loc=\"upper center\", bbox_to_anchor=(0.5, 1.5), fontsize = 5)\n",
    "    vio.set_title(\"\")\n",
    "\n",
    "\n",
    "#-----------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Set up figure colors and style\n",
    "\n",
    "sns.set_style('whitegrid') \n",
    "sns.set_context('paper')\n",
    "\n",
    "custom_params = {\n",
    "    \"axes.spines.top\": False,\n",
    "    \"axes.spines.right\": False\n",
    "    }\n",
    "\n",
    "sns.set_theme(style=\"ticks\", rc=custom_params)\n",
    "\n",
    "plt.rcParams.update({\n",
    "    'font.size':6,\n",
    "    'axes.linewidth':0.75,\n",
    "    'pdf.fonttype':42,\n",
    "    'ps.fonttype':42,\n",
    "    'axes.labelsize':6,\n",
    "    'axes.titlesize':6,\n",
    "    'xtick.labelsize':5,\n",
    "    'ytick.labelsize':5,\n",
    "    'legend.fontsize':6,\n",
    "    'legend.title_fontsize':6,\n",
    "    'legend.frameon': False,\n",
    "    'legend.markerscale':2,\n",
    "    'xtick.major.size':2,\n",
    "    'ytick.major.size':2\n",
    "})\n",
    "\n",
    "dataset_specific_colors = [\"#E58044\", \"#046C7C\", \"#85459B\"] # , \n",
    "\n",
    "\n",
    "#-------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Generate the figure\n",
    "\n",
    "\n",
    "plotheight = 100\n",
    "plotwidth = 300\n",
    "font_size = 5\n",
    "\n",
    "fig = plt.figure()\n",
    "fig.set_size_inches([plotwidth/72, plotheight/72])\n",
    "gs = GridSpec(nrows=7, ncols=12, figure=fig, hspace=0.3, wspace=2)\n",
    "\n",
    "columns_to_plot = ['PRE', 'POST', 'PRE w/ POST']\n",
    "\n",
    "#--------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Sample session *Panel d*\n",
    "\n",
    "ax_0 = fig.add_subplot(gs[:, 0:4])\n",
    "\n",
    "sample_session_index = 1\n",
    "\n",
    "curr_row_indexes = np.where(mean_moving_window_correlations_z_sessions_concat['session_number'] == sample_session_index)[0]\n",
    "curr_data_to_plot = mean_moving_window_correlations_z_sessions_concat.loc[curr_row_indexes, columns_to_plot]\n",
    "\n",
    "plot_violin(ax_0, curr_data_to_plot, (.55,.55,.55))\n",
    "sns.stripplot(data=curr_data_to_plot, jitter = 0.15, palette='dark:k', size=0.8, alpha=0.8)\n",
    "\n",
    "medians = np.empty((3,))\n",
    "for column_index, column in enumerate(columns_to_plot):\n",
    "    _,p_value = wilcoxon(curr_data_to_plot[column])\n",
    "    medians[column_index] = np.nanmedian(curr_data_to_plot[column])\n",
    "    ax_0.text(column_index, 32, get_pval_statement(p_value), fontsize=4, ha = 'center', color = 'gray')\n",
    "\n",
    "\n",
    "ax_0.set_ylim([-12, 40])\n",
    "ax_0.set_ylabel('LT stability (z)', labelpad=1)\n",
    "ax_0.set_title('Sample session')\n",
    "\n",
    "\n",
    "ax_0.set_xticklabels(columns_to_plot,rotation=35, ha= 'right')\n",
    "ax_0.set_yticks(np.arange(-10, 40.01, 10))\n",
    "\n",
    "ax_0.tick_params(axis = 'both', which='major',length=1, pad=1)\n",
    "\n",
    "\n",
    "\n",
    "#------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Pooled results *Panel e*\n",
    "\n",
    "ax_1 = fig.add_subplot(gs[:, 5:9])\n",
    "\n",
    "plot_violin(ax_1, mean_moving_window_correlations_z_sessions_concat[columns_to_plot], (.55,.55,.55))\n",
    "\n",
    "# Plot the medians\n",
    "\n",
    "# # other sessions\n",
    "# other_sessions_indexes = np.setdiff1d(included_session_IDX, sample_session_index)\n",
    "# row_indexes = mean_moving_window_correlations_z_median_sessions_concat['session_number'].isin(other_sessions_indexes)\n",
    "\n",
    "# jitter = 0.2\n",
    "\n",
    "# for column_index, column in enumerate(columns_to_plot):\n",
    "#     current_jitter = np.random.uniform(-jitter, jitter, len(other_sessions_indexes))\n",
    "#     sns.scatterplot(x = column_index+current_jitter, y = mean_moving_window_correlations_z_median_sessions_concat.loc[row_indexes, column], color = 'white', alpha=0.7,  s = 1.5, edgecolor='black', linewidth = 0.3, zorder= 2) \n",
    "\n",
    "\n",
    "# # sample session\n",
    "# row_index = mean_moving_window_correlations_z_median_sessions_concat['session_number'] == sample_session_index\n",
    "# sns.stripplot(data = mean_moving_window_correlations_z_median_sessions_concat.loc[row_index, columns_to_plot], jitter = 0.2, palette = 'dark:k', size=1.54, alpha=0.8)\n",
    "\n",
    "jitter = 0.075\n",
    "for session_idx in range(number_of_sessions):\n",
    "    session_number = included_session_IDX[session_idx]\n",
    "\n",
    "    if session_number in range(5):\n",
    "        color = dataset_specific_colors[0]\n",
    "    elif session_number in range(6,11):\n",
    "        color = dataset_specific_colors[1]\n",
    "    else:\n",
    "        color = dataset_specific_colors[2]\n",
    "\n",
    "    if session_number == sample_session_index:\n",
    "        linewidth = 0.75\n",
    "        marker_size = 3\n",
    "        z_order = 5\n",
    "        alpha = 0.8\n",
    "    else:\n",
    "        linewidth = 0.5\n",
    "        marker_size = 2\n",
    "        z_order = 4\n",
    "        alpha = 0.6\n",
    "\n",
    "    row_index = mean_moving_window_correlations_z_median_sessions_concat['session_number'] == session_number\n",
    "    current_x_location = np.arange(3)+np.random.uniform(-jitter, jitter, 3)\n",
    "    current_y_values = mean_moving_window_correlations_z_median_sessions_concat.loc[row_index, columns_to_plot].values.flatten()\n",
    "    ax_1.plot(current_x_location, current_y_values, color = color, linewidth = linewidth, alpha=alpha, zorder = z_order)\n",
    "    sns.scatterplot(x = current_x_location, y = current_y_values, color = color, alpha=alpha,  s = marker_size, edgecolor='None', linewidth = 0, zorder= z_order) \n",
    "\n",
    "\n",
    "\n",
    "# Wilcoxon tests\n",
    "\n",
    "# For each column's difference from zero\n",
    "pooled_medians = np.empty((3,))\n",
    "for column_index, column in enumerate(columns_to_plot):\n",
    "    pooled_medians[column_index] = np.nanmedian(mean_moving_window_correlations_z_median_sessions_concat[column])\n",
    "    _, p_value = wilcoxon(mean_moving_window_correlations_z_median_sessions_concat[column])\n",
    "    ax_1.text(column_index, 30, get_pval_statement(p_value), fontsize = 4, ha = 'center', color = 'gray')\n",
    "\n",
    "\n",
    "# Between the columns\n",
    "for column_i_index in range(len(columns_to_plot)):\n",
    "    column_i = columns_to_plot[column_i_index]\n",
    "\n",
    "    t = 0\n",
    "    for column_j_index in range(column_i_index+1, len(columns_to_plot)):\n",
    "        column_j = columns_to_plot[column_j_index]\n",
    "\n",
    "        _, p_value = wilcoxon(mean_moving_window_correlations_z_median_sessions_concat[column_i], mean_moving_window_correlations_z_median_sessions_concat[column_j])\n",
    "\n",
    "        y = 34+t*6\n",
    "        ax_1.plot([column_i_index+0.05, column_j_index-0.05], [y,y], color = 'k', linewidth=0.5)\n",
    "        ax_1.text(np.mean([column_i_index, column_j_index]), 35+t*6, get_pval_statement(p_value), fontsize=4, ha = 'center')\n",
    "\n",
    "        t =+ 1\n",
    "\n",
    "\n",
    "ax_1.set_ylim([-12, 40])\n",
    "ax_1.set_ylabel('LT stability (z)', labelpad=1)\n",
    "\n",
    "\n",
    "ax_1.set_xticklabels(columns_to_plot,rotation=35, ha= 'right')\n",
    "ax_1.set_yticks(np.arange(-10, 40.01, 10))\n",
    "\n",
    "ax_1.tick_params(axis = 'both', which='major',length=1, pad=1)\n",
    "\n",
    "\n",
    "#---------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Relationship between stability and fidelity * Panel f*\n",
    "\n",
    "# Divide the units into stable and unstable categories and compare the PF fidelity between them\n",
    "\n",
    "ax2 = fig.add_subplot(gs[1:, 10:])\n",
    "\n",
    "plot_violin2(ax2, LT_fidelities_stability_split, (.2,.2,.2,.8))\n",
    "\n",
    "ax2.set_xlabel('')\n",
    "ax2.set_ylabel('PF fidelity', labelpad=1)\n",
    "ax2.tick_params(axis='both', which='major', labelsize=5, length=1, pad=1)\n",
    "ax2.yaxis.set_major_formatter(FuncFormatter(format_ticks))\n",
    "ax2.set_xticklabels(sleep_epoch_names,rotation=35, ha= 'right')\n",
    "ax2.set_ylim([-0.7, 1.1])\n",
    "\n",
    "\n",
    "\n",
    "# Statistal tests of the medians and their differences\n",
    "median_fidelity_stable_group = dict.fromkeys(sleep_epoch_names)\n",
    "iqr_fidelity_stable_group = dict.fromkeys(sleep_epoch_names) #interquartile range\n",
    "p_value_fidelity_stable_group = dict.fromkeys(sleep_epoch_names)\n",
    "\n",
    "median_fidelity_unstable_group = dict.fromkeys(sleep_epoch_names)\n",
    "iqr_fidelity_unstable_group = dict.fromkeys(sleep_epoch_names)\n",
    "p_value_fidelity_unstable_group = dict.fromkeys(sleep_epoch_names)\n",
    "\n",
    "\n",
    "for epoch_index, epoch in enumerate(sleep_epoch_names):\n",
    "\n",
    "    stable_group = (\n",
    "        (LT_fidelities_stability_split['epoch'] == epoch) &\n",
    "        (LT_fidelities_stability_split['stability_status'] == 'stable')\n",
    "    )\n",
    "    stable_fidelities = LT_fidelities_stability_split.loc[stable_group, 'LT_fidelity']\n",
    "    median_fidelity_stable_group[epoch] = np.nanmedian(stable_fidelities , axis = 0)\n",
    "    iqr_fidelity_stable_group[epoch] = np.nanpercentile(stable_fidelities, 75) - np.nanpercentile(stable_fidelities, 25)\n",
    "\n",
    "\n",
    "    ui_fidelities_stable_group = np.stack(LT_fidelities_stability_split.loc[stable_group, 'LT_fidelity_ui'].to_numpy(), axis = 0)\n",
    "    ui_median_fidelity_stable_group = np.nanmedian(ui_fidelities_stable_group, axis = 0)\n",
    "\n",
    "    p_value_fidelity_stable_group[epoch] = np.sum(ui_median_fidelity_stable_group >= median_fidelity_stable_group[epoch])/num_shuffles\n",
    "\n",
    "\n",
    "\n",
    "    unstable_group = (\n",
    "        (LT_fidelities_stability_split['epoch'] == epoch) &\n",
    "        (LT_fidelities_stability_split['stability_status'] == 'unstable')\n",
    "    )\n",
    "    unstable_fidelities = LT_fidelities_stability_split.loc[unstable_group, 'LT_fidelity']\n",
    "    median_fidelity_unstable_group[epoch] = np.nanmedian(unstable_fidelities , axis = 0)\n",
    "    iqr_fidelity_unstable_group[epoch] = np.nanpercentile(unstable_fidelities, 75) - np.nanpercentile(unstable_fidelities, 25)\n",
    "\n",
    "\n",
    "    ui_fidelities_unstable_group = np.stack(LT_fidelities_stability_split.loc[unstable_group, 'LT_fidelity_ui'].to_numpy(), axis = 0)\n",
    "    ui_median_fidelity_unstable_group = np.nanmedian(ui_fidelities_unstable_group, axis = 0)\n",
    "\n",
    "    p_value_fidelity_unstable_group[epoch] = np.sum(ui_median_fidelity_unstable_group >= median_fidelity_unstable_group[epoch])/num_shuffles\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "    _, p_value = ranksums(stable_fidelities, unstable_fidelities)\n",
    "\n",
    "    y = 1.05\n",
    "    ax2.plot([epoch_index-0.15, epoch_index+0.15], [y,y], color = 'k', linewidth=1)\n",
    "    ax2.text(epoch_index, 1.1, get_pval_statement(p_value), fontsize=4, ha = 'center')\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "plt.subplots_adjust(left=0.07, right= 0.95, bottom=0.25, top=0.85)\n",
    "\n",
    "filename = 'Figure3_panels_e_f_v2'\n",
    "file_path = os.path.join(data_dir, filename)\n",
    "plt.savefig(file_path, format='pdf', dpi=300)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'PRE': 0.3537, 'POST': 0.0002}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p_value_fidelity_unstable_group"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/kouroshmaboudi/miniconda3/envs/learned_tuning_project_env/lib/python3.9/site-packages/numpy/lib/nanfunctions.py:1217: RuntimeWarning: All-NaN slice encountered\n",
      "  r, k = function_base._ureduce(a, func=_nanmedian, axis=axis, out=out,\n"
     ]
    }
   ],
   "source": [
    "# load REM learned tunings calculated in MATLAB\n",
    "\n",
    "num_shuffles = 10000\n",
    "\n",
    "for session_idx in range(number_of_sessions):\n",
    "\n",
    "    session_number = current_sessions[session_idx]\n",
    "    session_name = rr[session_number]\n",
    "\n",
    "\n",
    "    session_dataset_path = os.path.join(main_dir, session_name)\n",
    "\n",
    "    filename = f'{session_name}.assemblyTunings_REM_0.020.mat'\n",
    "    file_path = os.path.join(session_dataset_path, 'NREM_REM_with_posterior_ginis', filename)\n",
    "    mat_file = loadmat(file_path)\n",
    "    \n",
    "    for epoch in ['pre', 'post']:\n",
    "    \n",
    "        original_learned_tunings = mat_file['assemblyTunings'][epoch][0][0][0][0][0]\n",
    "\n",
    "        gini_coeffs[session_idx][epoch]['REM'] = mat_file['posteriors_gini_coeffs'][epoch][0][0]\n",
    "\n",
    "        num_units, num_pos_bins = original_learned_tunings.shape\n",
    "\n",
    "        interp_pos_bins = np.linspace(0, num_pos_bins, 200)\n",
    "        num_pos_bins_interp = len(interp_pos_bins)\n",
    "    \n",
    "\n",
    "        learned_tunings[session_idx][epoch]['REM'] = np.full((num_units, num_pos_bins_interp), np.nan)\n",
    "\n",
    "        for unit in range(num_units):\n",
    "            current_unit_lt = original_learned_tunings[unit].reshape(num_pos_bins)\n",
    "            current_unit_lt = np.interp(interp_pos_bins, np.arange(0, num_pos_bins), current_unit_lt)\n",
    "            current_unit_lt[np.isnan(current_unit_lt)] = 0\n",
    "\n",
    "            learned_tunings[session_idx][epoch]['REM'][unit] = np.convolve(current_unit_lt, gw, mode='same')\n",
    "\n",
    "\n",
    "        learned_tunings_place_field_corr[session_idx][epoch]['REM'] = np.full((num_units,), np.nan)\n",
    "        learned_tunings_place_field_corr[session_idx][epoch]['REM'][stable_above_1Hz_PF_unit_index[session_idx]], _, _ = calculate_place_field_fidelity_of_learned_tuning(\n",
    "                    learned_tunings[session_idx][epoch]['REM'][stable_above_1Hz_PF_unit_index[session_idx]],\n",
    "                    spatial_tunings_maze[session_idx][stable_above_1Hz_PF_unit_index[session_idx]],  \n",
    "                    num_shuffles\n",
    "                )\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Moving time window LTs' PF fidelities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_epochs = len(epoch_names)\n",
    "\n",
    "#------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Calculate the z-scored moving time window LT fidelity for each session\n",
    "\n",
    "sessions = [d for d in os.listdir(data_dir) if os.path.isdir(os.path.join(data_dir, d))]\n",
    "included_session_IDX = [x for x in range(17) if x not in (12, 13)]\n",
    "\n",
    "total_num_sessions = len(included_session_IDX)\n",
    "\n",
    "# included_session_IDX = np.arange(6,11)\n",
    "\n",
    "sessions = [sessions[i] for i in included_session_IDX]\n",
    "\n",
    "moving_time_window_centers = [None]*len(sessions)\n",
    "moving_time_window_LTs = [None]*len(sessions)\n",
    "moving_time_window_LT_median_fidelity_z_score = [None]*len(sessions)\n",
    "\n",
    "for session_idx, session_name in enumerate(sessions):\n",
    "\n",
    "    session_dataset_path = os.path.join(data_dir, session_name)\n",
    "    session_number = included_session_IDX[session_idx]\n",
    "\n",
    "    \n",
    "    filename = f'{session_name}.learned_tunings_vs_time_all_offline.npy'\n",
    "    file_path = os.path.join(session_dataset_path, filename)\n",
    "        \n",
    "    learned_tunings_vs_time_all_offline = np.load(file_path, allow_pickle = True).item()\n",
    "\n",
    "\n",
    "    moving_time_window_centers[session_idx] = dict.fromkeys(epoch_names)\n",
    "    \n",
    "    moving_time_window_LTs[session_idx] = dict.fromkeys(epoch_names)\n",
    "    moving_time_window_LT_median_fidelity_z_score[session_idx] = dict.fromkeys(epoch_names)\n",
    "\n",
    "\n",
    "    for epoch_index, epoch in enumerate(epoch_names):\n",
    "        \n",
    "        win_centers = learned_tunings_vs_time_all_offline[epoch]['win_centers']\n",
    "        moving_window_LT_fidelity = learned_tunings_vs_time_all_offline[epoch]['median_LT_PF_pearson_corr_all_offline_across_time']\n",
    "\n",
    "        moving_time_window_centers[session_idx][epoch] = win_centers/3600 # in hours\n",
    "        \n",
    "        moving_time_window_LTs[session_idx][epoch] = learned_tunings_vs_time_all_offline[epoch]['learned_tunings_all_offline_across_time']\n",
    "\n",
    "        moving_time_window_LT_median_fidelity_z_score[session_idx][epoch] = np.full((win_centers.shape[0],), np.nan)\n",
    "        for time_window_index, time_window in enumerate(win_centers):\n",
    "            \n",
    "            time_window_LT_fidelity_data = moving_window_LT_fidelity[time_window_index]['data']\n",
    "            time_window_LT_fidleity_ui = moving_window_LT_fidelity[time_window_index]['PF_unit_IDX_shuffle']\n",
    "\n",
    "            moving_time_window_LT_median_fidelity_z_score[session_idx][epoch][time_window_index] = (time_window_LT_fidelity_data - np.nanmean(time_window_LT_fidleity_ui))/np.nanstd(time_window_LT_fidleity_ui)\n",
    "\n",
    "\n",
    "#-------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Align the time bin centers within each epoch across all sessions\n",
    "\n",
    "# PRE time bin centers to the start of MAZE\n",
    "# MAZE time bin centers to the start of MAZE\n",
    "# POST time bin centers to the end of MAZE\n",
    "\n",
    "sessions_by_datasets = [None]*4 # there are three datasets: Grosmark, Giri, and Miyawaki datasets plus one additional set of indexes encompassing all sessions\n",
    "sessions_by_datasets[0] = np.arange(5)\n",
    "sessions_by_datasets[1] = np.arange(6,11)\n",
    "sessions_by_datasets[2] = np.setdiff1d(np.arange(15), np.concatenate(sessions_by_datasets[:2]))\n",
    "sessions_by_datasets[3] = np.arange(15)\n",
    "\n",
    "win_step_size = 1/12 # in hours\n",
    "\n",
    "\n",
    "num_windows_indiv_sessions = dict.fromkeys(epoch_names)\n",
    "for epoch in epoch_names:\n",
    "    num_windows_indiv_sessions[epoch] = np.full((total_num_sessions,), np.nan, dtype=int)\n",
    "    for session_idx in range(total_num_sessions):\n",
    "        num_windows_indiv_sessions[epoch][session_idx] = len(moving_time_window_centers[session_idx][epoch])\n",
    "\n",
    "\n",
    "\n",
    "max_num_windows_across_sessions = [None]*4\n",
    "moving_time_window_centers_aligned = [None]*4\n",
    "\n",
    "\n",
    "# Aligning each set of session indexes separately\n",
    "for dataset_index in range(4):\n",
    "\n",
    "    current_dataset_session_indexes = sessions_by_datasets[dataset_index]\n",
    "\n",
    "    max_num_windows_across_sessions[dataset_index] = dict.fromkeys(epoch_names)\n",
    "\n",
    "\n",
    "    moving_time_window_centers_aligned[dataset_index] = dict.fromkeys(epoch_names) # aligned specifically for each dataset \n",
    "\n",
    "    for epoch_index, epoch in enumerate(epoch_names):\n",
    "\n",
    "        if epoch_index == 0:\n",
    "            curr_epoch_aligned_start = 0\n",
    "        else:\n",
    "            prev_epoch = epoch_names[epoch_index-1]\n",
    "            curr_epoch_aligned_start = moving_time_window_centers_aligned[dataset_index][prev_epoch][-1]\n",
    "\n",
    "        max_num_windows_across_sessions[dataset_index][epoch] = np.amax(num_windows_indiv_sessions[epoch][current_dataset_session_indexes])\n",
    "        moving_time_window_centers_aligned[dataset_index][epoch] = curr_epoch_aligned_start + np.arange(max_num_windows_across_sessions[dataset_index][epoch])*win_step_size + win_step_size/2\n",
    "\n",
    "\n",
    "\n",
    "# Align the LT fidelities across all sessions within all datasets\n",
    "\n",
    "moving_window_LT_fidelities_time_windows_aligned = dict.fromkeys(epoch_names) # aligned across all sessions (including all datasets) - the 4th set of sessions indexes will be used for calculating this\n",
    "\n",
    "dataset_index = 3\n",
    "for epoch_index, epoch in enumerate(epoch_names):\n",
    "\n",
    "    moving_window_LT_fidelities_time_windows_aligned[epoch] = [None]*total_num_sessions\n",
    "    for session_idx in sessions_by_datasets[dataset_index]:\n",
    "    \n",
    "        num_units, num_pos_bins,_ = moving_time_window_LTs[session_idx][epoch].shape\n",
    "\n",
    "        if epoch == 'PRE':  # aligning all sessions to the end of the epoch \n",
    "            current_session_aligned_time_window_indexes = np.arange((max_num_windows_across_sessions[dataset_index][epoch] - num_windows_indiv_sessions[epoch][session_idx]), max_num_windows_across_sessions[dataset_index][epoch])\n",
    "        else:  # for MAZE and POST aligning to the start of the epoch\n",
    "            current_session_aligned_time_window_indexes = np.arange(num_windows_indiv_sessions[epoch][session_idx])\n",
    "\n",
    "        moving_window_LT_fidelities_time_windows_aligned[epoch][session_idx] = np.full((max_num_windows_across_sessions[dataset_index][epoch],), np.nan)\n",
    "        moving_window_LT_fidelities_time_windows_aligned[epoch][session_idx][current_session_aligned_time_window_indexes] = moving_time_window_LT_median_fidelity_z_score[session_idx][epoch]\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the average moving time window correlation matrices separately for each dataset\n",
    "\n",
    "num_shuffles = 500\n",
    "\n",
    "moving_window_LTs_time_windows_aligned = dict.fromkeys(epoch_names)\n",
    "\n",
    "for epoch in epoch_names:\n",
    "    moving_window_LTs_time_windows_aligned[epoch] = [None]*total_num_sessions\n",
    "\n",
    "moving_window_correlation_mat_data = [None]*total_num_sessions\n",
    "moving_window_correlation_mat_ui = [None]*total_num_sessions\n",
    "moving_window_correlation_mat_z_score = [None]*total_num_sessions\n",
    "\n",
    "for dataset_index in range(3):\n",
    "\n",
    "    current_dataset_session_indexes = sessions_by_datasets[dataset_index]\n",
    "\n",
    "\n",
    "    epoch_start_time_bin = dict.fromkeys(epoch_names)\n",
    "    for epoch_index, epoch in enumerate(epoch_names):\n",
    "        if epoch_index == 0:\n",
    "            epoch_start_time_bin['PRE'] = 0\n",
    "        else: \n",
    "            prev_epoch = epoch_names[epoch_index-1]\n",
    "            epoch_start_time_bin[epoch] = epoch_start_time_bin[prev_epoch] + max_num_windows_across_sessions[dataset_index][prev_epoch]\n",
    "\n",
    "    num_time_bins_summed_over_epochs = max_num_windows_across_sessions[dataset_index]['PRE'] + max_num_windows_across_sessions[dataset_index]['MAZE'] + max_num_windows_across_sessions[dataset_index]['POST']\n",
    "\n",
    "\n",
    "    for session_idx in current_dataset_session_indexes:\n",
    "\n",
    "\n",
    "        print(sessions[session_idx])\n",
    "\n",
    "        num_units, num_pos_bins, _ = moving_time_window_LTs[session_idx]['PRE'].shape\n",
    "\n",
    "        \n",
    "\n",
    "        # Align the moving window LTs\n",
    "        for epoch in epoch_names:\n",
    "\n",
    "            if epoch == 'PRE':  # aligning all sessions to the end of the epoch \n",
    "                current_session_aligned_time_window_indexes = np.arange((max_num_windows_across_sessions[dataset_index][epoch] - num_windows_indiv_sessions[epoch][session_idx]), max_num_windows_across_sessions[dataset_index][epoch])\n",
    "            else:  # for MAZE and POST aligning to the start of the epoch\n",
    "                current_session_aligned_time_window_indexes = np.arange(num_windows_indiv_sessions[epoch][session_idx])\n",
    "\n",
    "            moving_window_LTs_time_windows_aligned[epoch][session_idx] = np.full((num_units, num_pos_bins, max_num_windows_across_sessions[dataset_index][epoch]), np.nan)\n",
    "            moving_window_LTs_time_windows_aligned[epoch][session_idx][:, :, current_session_aligned_time_window_indexes] = moving_time_window_LTs[session_idx][epoch]\n",
    "\n",
    "\n",
    "\n",
    "        moving_window_correlation_mat_data[session_idx] = np.full((num_time_bins_summed_over_epochs, num_time_bins_summed_over_epochs, num_units), np.nan)\n",
    "        moving_window_correlation_mat_ui[session_idx] = np.full((num_time_bins_summed_over_epochs, num_time_bins_summed_over_epochs, num_shuffles), np.nan)\n",
    "        # moving_window_correlation_mat_z_score[session_idx] = np.full((num_time_bins_summed_over_epochs, num_time_bins_summed_over_epochs, num_units), np.nan)\n",
    "\n",
    "        for epoch_x_index in range(num_epochs):\n",
    "            epoch_x  = epoch_names[epoch_x_index]\n",
    "\n",
    "            epoch_x_moving_time_window_LT = moving_window_LTs_time_windows_aligned[epoch_x][session_idx]\n",
    "            slice_start_x = epoch_start_time_bin[epoch_x] \n",
    "            slice_stop_x = slice_start_x + max_num_windows_across_sessions[dataset_index][epoch_x]\n",
    "\n",
    "            for epoch_y_index in range(epoch_x_index, num_epochs):\n",
    "                epoch_y = epoch_names[epoch_y_index]\n",
    "                print(epoch_x + ' vs ' + epoch_y)\n",
    "\n",
    "                epoch_y_moving_time_window_LT = moving_window_LTs_time_windows_aligned[epoch_y][session_idx]\n",
    "                slice_start_y = epoch_start_time_bin[epoch_y] \n",
    "                slice_stop_y = slice_start_y + max_num_windows_across_sessions[dataset_index][epoch_y]\n",
    "\n",
    "\n",
    "                # Data\n",
    "                # print('Data ...')\n",
    "\n",
    "                for unit in stable_above_1Hz_PF_unit_index[session_idx]:\n",
    "\n",
    "                    curr_unit_tuning_epoch_x = np.squeeze(epoch_x_moving_time_window_LT[unit, :, :])  # learned tuning in the first epoch\n",
    "                    if (curr_unit_tuning_epoch_x.ndim == 1):\n",
    "                        curr_unit_tuning_epoch_x = curr_unit_tuning_epoch_x.reshape(-1,1)\n",
    "\n",
    "                    curr_unit_tuning_epoch_y = np.squeeze(epoch_y_moving_time_window_LT[unit, :, :])  # learned tuning in the second epoch (could be the same as first)\n",
    "                    if (curr_unit_tuning_epoch_y.ndim == 1):\n",
    "                        curr_unit_tuning_epoch_y = curr_unit_tuning_epoch_y.reshape(-1,1)\n",
    "\n",
    "                    curr_moving_window_corr_mat = calculate_moving_time_window_correlations(curr_unit_tuning_epoch_y, curr_unit_tuning_epoch_x)\n",
    "                    \n",
    "                    moving_window_correlation_mat_data[session_idx][\n",
    "                        slice_start_y: slice_stop_y,\n",
    "                        slice_start_x: slice_stop_x, unit] = curr_moving_window_corr_mat\n",
    "                    \n",
    "                    if epoch_x != epoch_y:\n",
    "                        moving_window_correlation_mat_data[session_idx][\n",
    "                            slice_start_x: slice_stop_x,\n",
    "                            slice_start_y: slice_stop_y, unit] = np.transpose(curr_moving_window_corr_mat)\n",
    "                        \n",
    "\n",
    "                # Shuffle\n",
    "                # print('Shuffle ...')\n",
    "\n",
    "                num_time_bins_epoch_x = epoch_x_moving_time_window_LT.shape[2]\n",
    "                shuffled_units_epoch_x = np.random.choice(stable_above_1Hz_PF_unit_index[session_idx], size=(num_shuffles, num_time_bins_epoch_x))\n",
    "\n",
    "                num_time_bins_epoch_y = epoch_y_moving_time_window_LT.shape[2]\n",
    "                shuffled_units_epoch_y = np.random.choice(stable_above_1Hz_PF_unit_index[session_idx], size=(num_shuffles, num_time_bins_epoch_y))\n",
    "                \n",
    "\n",
    "                for shuffle_index in range(num_shuffles):\n",
    "\n",
    "                    # Generate shuffle tunings by randomly choosing a unit within every time bin \n",
    "                    shuffled_epoch_x_moving_time_window_LT = np.zeros((num_pos_bins, num_time_bins_epoch_x))\n",
    "                    for time_bin_index in range(num_time_bins_epoch_x):\n",
    "                        shuffled_epoch_x_moving_time_window_LT[:, time_bin_index] = np.squeeze(epoch_x_moving_time_window_LT[shuffled_units_epoch_x[shuffle_index, time_bin_index], :,  time_bin_index])\n",
    "\n",
    "\n",
    "                    shuffled_epoch_y_moving_time_window_LT = np.zeros((num_pos_bins, num_time_bins_epoch_y))\n",
    "                    for time_bin_index in range(num_time_bins_epoch_y):\n",
    "                        shuffled_epoch_y_moving_time_window_LT[:, time_bin_index] = np.squeeze(epoch_y_moving_time_window_LT[shuffled_units_epoch_y[shuffle_index, time_bin_index], :,  time_bin_index])\n",
    "\n",
    "                    \n",
    "                    curr_moving_window_corr_mat = calculate_moving_time_window_correlations(shuffled_epoch_y_moving_time_window_LT, shuffled_epoch_x_moving_time_window_LT)\n",
    "                    \n",
    "                    moving_window_correlation_mat_ui[session_idx][\n",
    "                        slice_start_y: slice_stop_y,\n",
    "                        slice_start_x: slice_stop_x, shuffle_index] = curr_moving_window_corr_mat\n",
    "                    \n",
    "                    if epoch_x != epoch_y:\n",
    "                        moving_window_correlation_mat_ui[session_idx][\n",
    "                            slice_start_x: slice_stop_x,\n",
    "                            slice_start_y: slice_stop_y, shuffle_index] = np.transpose(curr_moving_window_corr_mat)\n",
    "                            \n",
    "\n",
    "\n",
    "        mean_array = np.nanmean(moving_window_correlation_mat_ui[session_idx], axis=2)\n",
    "        std_array = np.nanstd(moving_window_correlation_mat_ui[session_idx], axis=2)\n",
    "\n",
    "        mean_array = np.repeat(mean_array[:,:, np.newaxis], num_units, axis = 2)\n",
    "        std_array = np.repeat(std_array[:,:, np.newaxis], num_units, axis = 2)\n",
    "\n",
    "        moving_window_correlation_mat_z_score[session_idx] = (\n",
    "            moving_window_correlation_mat_data[session_idx] - mean_array\n",
    "        ) / std_array\n",
    "\n",
    "\n",
    "    # moving_window_correlation_mat_pooled = np.concatenate(moving_window_correlation_mat_z_score, axis = 2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.ticker as ticker\n",
    "from scipy.stats import wilcoxon\n",
    "\n",
    "def remove_trailing_zeros(x, pos):\n",
    "    formatted_label = f\"{int(x):d}\" if x == int(x) else f\"{x:.1f}\"\n",
    "    return formatted_label\n",
    "\n",
    "\n",
    "def get_pval_statement(pvalue):\n",
    "    if pvalue < 0.0001:\n",
    "        pvalue_statement = '**'\n",
    "    else:\n",
    "        pvalue_statement = f'P={pvalue:.4f}'\n",
    "    return pvalue_statement\n",
    "\n",
    "#-----------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Set up figure colors and style\n",
    "\n",
    "sns.set_style('whitegrid') \n",
    "sns.set_context('paper')\n",
    "\n",
    "custom_params = {\n",
    "    \"axes.spines.top\": False,\n",
    "    \"axes.spines.right\": False\n",
    "    }\n",
    "\n",
    "sns.set_theme(style=\"ticks\", rc=custom_params)\n",
    "\n",
    "plt.rcParams.update({\n",
    "    'font.size':5,\n",
    "    'axes.linewidth':0.5,\n",
    "    'pdf.fonttype':42,\n",
    "    'ps.fonttype':42,\n",
    "    'axes.labelsize':5,\n",
    "    'axes.titlesize':5,\n",
    "    'xtick.labelsize':5,\n",
    "    'ytick.labelsize':5,\n",
    "    'legend.fontsize':5,\n",
    "    'legend.title_fontsize':6,\n",
    "    'legend.frameon': False,\n",
    "    'legend.markerscale':2,\n",
    "    'xtick.major.size':2,\n",
    "    'ytick.major.size':2\n",
    "})\n",
    "\n",
    "\n",
    "epoch_colors = [\n",
    "    '#005CE9', # PRE\n",
    "    'black', # MAZE\n",
    "    '#DD335D', # POST\n",
    "    ] \n",
    "\n",
    "dataset_names = ['Grosmark_dataset', 'Giri_dataset', 'Miyawaki_dataset']\n",
    "dataset_specific_colors = [\"#E58044\", \"#046C7C\", \"#85459B\"] # , \n",
    "\n",
    "#--------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "\n",
    "total_num_time_windows_aligned = np.full((3,), np.nan)\n",
    "for dataset_index in range(3):\n",
    "    total_num_time_windows_aligned[dataset_index] = max_num_windows_across_sessions[dataset_index]['PRE'] + max_num_windows_across_sessions[dataset_index]['MAZE'] + max_num_windows_across_sessions[dataset_index]['POST']\n",
    "\n",
    "max_total_num_time_windows_across_datasets = np.max(total_num_time_windows_aligned)\n",
    "\n",
    "#--------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Plot the moving window LT correlation matrices separately for each dataset\n",
    "\n",
    "epoch_indicator_bar_width = 0.03\n",
    "epoch_indicator_bar_pad = 0.02\n",
    "epoch_indicator_bar_total_width = epoch_indicator_bar_width + epoch_indicator_bar_pad\n",
    "\n",
    "z_score_stability_time_window_aligned = [None]*3\n",
    "\n",
    "for dataset_index, dataset_name in enumerate(dataset_names):\n",
    "\n",
    "    current_session_indexes = sessions_by_datasets[dataset_index]\n",
    "\n",
    "\n",
    "    plotwidth = 110\n",
    "    plotheight = 70\n",
    "    \n",
    "    fig = plt.figure()\n",
    "    fig.set_size_inches([plotwidth/72, plotheight/72])\n",
    "    gs = GridSpec(nrows= 1, ncols=2, figure=fig, width_ratios = [0.5, 0.5], hspace=0.2, wspace=0.5)\n",
    "\n",
    "    # Moving time window LT correlation matrix\n",
    "\n",
    "    ax1 = fig.add_subplot(gs[0])\n",
    "\n",
    "    ax1.set_aspect('equal')\n",
    "    ax1.axis('off')\n",
    "\n",
    "    ratio = total_num_time_windows_aligned[dataset_index]/max_total_num_time_windows_across_datasets\n",
    "    ax1 = ax1.inset_axes([(1-ratio)/2,(1-ratio)/2, ratio, ratio])\n",
    "    ax1.axis('off')\n",
    "\n",
    "    ax1.set_title(dataset_name.replace('_', ' '), fontsize=5, pad = 3)\n",
    "\n",
    "    corr_mat_ax = ax1.inset_axes([epoch_indicator_bar_total_width, epoch_indicator_bar_total_width, 1-epoch_indicator_bar_total_width, 1-epoch_indicator_bar_total_width])\n",
    "    \n",
    "    moving_window_correlation_mat_pooled = np.concatenate([moving_window_correlation_mat_z_score[x] for x in current_session_indexes], axis = 2)\n",
    "    moving_window_correlation_mat_pooled_mean = np.nanmean(moving_window_correlation_mat_pooled, axis=2)\n",
    "    # moving_window_correlation_mat_pooled_mean[np.isnan(moving_window_correlation_mat_pooled_mean)] = 0 # replace nan with zeros\n",
    "\n",
    "\n",
    "    corr_mat_ax.imshow(moving_window_correlation_mat_pooled_mean, vmin=-1, vmax = 1, cmap = 'coolwarm', origin='lower', interpolation='None')\n",
    "\n",
    "    print(np.nanmin(moving_window_correlation_mat_pooled_mean.flatten()))\n",
    "\n",
    "    offset = 0\n",
    "    corr_mat_ax.axvline(x = max_num_windows_across_sessions[dataset_index]['PRE']+offset, color='gray', linestyle='-', linewidth=0.3)\n",
    "    corr_mat_ax.axvline(x = max_num_windows_across_sessions[dataset_index]['PRE'] + max_num_windows_across_sessions[dataset_index]['MAZE']+offset, color='gray', linestyle='-', linewidth=0.3)\n",
    "    corr_mat_ax.axhline(y = max_num_windows_across_sessions[dataset_index]['PRE']+offset, color='gray', linestyle='-', linewidth=0.3)\n",
    "    corr_mat_ax.axhline(y = max_num_windows_across_sessions[dataset_index]['PRE'] + max_num_windows_across_sessions[dataset_index]['MAZE']+offset, color='gray', linestyle='-', linewidth=0.3)\n",
    "\n",
    "\n",
    "    if dataset_index == 0: # Grosmark\n",
    "        old_xlim = corr_mat_ax.get_xlim()\n",
    "        corr_mat_ax.set_xlim([0, old_xlim[1]-5])\n",
    "        corr_mat_ax.set_ylim([0, old_xlim[1]-5])\n",
    "\n",
    "        axes_tick_mapping = [\n",
    "            [max_num_windows_across_sessions[dataset_index]['PRE']-4*12, -4],\n",
    "            [max_num_windows_across_sessions[dataset_index]['PRE']-2*12, -2],\n",
    "            [max_num_windows_across_sessions[dataset_index]['PRE'], 0],\n",
    "            [max_num_windows_across_sessions[dataset_index]['PRE'] + max_num_windows_across_sessions[dataset_index]['MAZE'], 0],\n",
    "            [max_num_windows_across_sessions[dataset_index]['PRE'] + max_num_windows_across_sessions[dataset_index]['MAZE']+2*12, 2],\n",
    "            [max_num_windows_across_sessions[dataset_index]['PRE'] + max_num_windows_across_sessions[dataset_index]['MAZE']+4*12, 4],            \n",
    "            ]  \n",
    "\n",
    "    elif dataset_index == 1: # Giri\n",
    "\n",
    "        old_xlim = corr_mat_ax.get_xlim()\n",
    "        corr_mat_ax.set_xlim([0, old_xlim[1]-24])\n",
    "        corr_mat_ax.set_ylim([0, old_xlim[1]-24])\n",
    "\n",
    "        axes_tick_mapping = [\n",
    "            [max_num_windows_across_sessions[dataset_index]['PRE']-2*12, -2],\n",
    "            [max_num_windows_across_sessions[dataset_index]['PRE'], 0],\n",
    "            [max_num_windows_across_sessions[dataset_index]['PRE'] + max_num_windows_across_sessions[dataset_index]['MAZE'], 0],\n",
    "            [max_num_windows_across_sessions[dataset_index]['PRE'] + max_num_windows_across_sessions[dataset_index]['MAZE']+2*12, 2],\n",
    "            [max_num_windows_across_sessions[dataset_index]['PRE'] + max_num_windows_across_sessions[dataset_index]['MAZE']+4*12, 4],\n",
    "            [max_num_windows_across_sessions[dataset_index]['PRE'] + max_num_windows_across_sessions[dataset_index]['MAZE']+6*12, 6],\n",
    "            [max_num_windows_across_sessions[dataset_index]['PRE'] + max_num_windows_across_sessions[dataset_index]['MAZE']+8*12, 8],\n",
    "            ]\n",
    "\n",
    "    elif dataset_index == 2: # Miyawaki\n",
    "\n",
    "        axes_tick_mapping = [\n",
    "            [max_num_windows_across_sessions[dataset_index]['PRE']-2*12, -2],\n",
    "            [max_num_windows_across_sessions[dataset_index]['PRE'], 0],\n",
    "            [max_num_windows_across_sessions[dataset_index]['PRE']+2*12, 2],\n",
    "            [max_num_windows_across_sessions[dataset_index]['PRE'] + max_num_windows_across_sessions[dataset_index]['MAZE'], 0],\n",
    "            [max_num_windows_across_sessions[dataset_index]['PRE'] + max_num_windows_across_sessions[dataset_index]['MAZE']+2*12, 2],\n",
    "            ]\n",
    "\n",
    "\n",
    "\n",
    "    axes_tick_mapping = np.array(axes_tick_mapping)\n",
    "\n",
    "    # corr_mat_ax.tick_params(axis='both', which='major', length=1, pad=1, width=0.5)\n",
    "    corr_mat_ax.axis('off')\n",
    "    corr_mat_ax.set_aspect('equal')\n",
    "\n",
    "\n",
    "    # ------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    # Epoch time span indicator bars - on left\n",
    "\n",
    "    epoch_bar_ax_left = ax1.inset_axes([0, epoch_indicator_bar_total_width, epoch_indicator_bar_width, 1-epoch_indicator_bar_total_width], sharey = corr_mat_ax)\n",
    "\n",
    "    for epoch_index, epoch in enumerate(epoch_names):\n",
    "        if epoch_index == 0:\n",
    "            y_start = 0\n",
    "            y_end = max_num_windows_across_sessions[dataset_index]['PRE']+offset\n",
    "        elif epoch_index == 1:\n",
    "            y_start = max_num_windows_across_sessions[dataset_index]['PRE']+offset\n",
    "            y_end = max_num_windows_across_sessions[dataset_index]['PRE'] + max_num_windows_across_sessions[dataset_index]['MAZE']+offset\n",
    "        elif epoch_index == 2:\n",
    "            y_start = max_num_windows_across_sessions[dataset_index]['PRE'] + max_num_windows_across_sessions[dataset_index]['MAZE']+offset\n",
    "            y_end = max_num_windows_across_sessions[dataset_index]['PRE'] + max_num_windows_across_sessions[dataset_index]['MAZE'] + max_num_windows_across_sessions[dataset_index]['POST']\n",
    "\n",
    "        epoch_bar_ax_left.axhspan(y_start, y_end, alpha=0.8, color=epoch_colors[epoch_index], linewidth= 0)\n",
    "\n",
    "\n",
    "    # epoch_bar_ax_left.set_xticks(axes_tick_mapping[:, 0], axes_tick_mapping[:, 1])\n",
    "    epoch_bar_ax_left.set_yticks(axes_tick_mapping[:, 0], axes_tick_mapping[:, 1])\n",
    "    epoch_bar_ax_left.xaxis.set_visible(False)\n",
    "    epoch_bar_ax_left.spines['bottom'].set_visible(False)\n",
    "\n",
    "    epoch_bar_ax_left.tick_params(axis='both', which='major', length=1, pad=0.5, width=0.5, labelsize = 4)\n",
    "    \n",
    "    epoch_bar_ax_left.set_ylabel('Time (hour)', fontsize=5, labelpad = 0)\n",
    "\n",
    "    if dataset_index == 2:\n",
    "        corr_mat_ax.set_ylim([0, y_end])\n",
    "    # ------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    # Epoch time span indicator bars - on bottom\n",
    "\n",
    "    epoch_bar_ax_bottom = ax1.inset_axes([epoch_indicator_bar_total_width, 0, 1-epoch_indicator_bar_total_width , epoch_indicator_bar_width], sharex = corr_mat_ax)\n",
    "\n",
    "    for epoch_index, epoch in enumerate(epoch_names):\n",
    "        if epoch == 'PRE':\n",
    "            x_start = 0\n",
    "            x_end = max_num_windows_across_sessions[dataset_index]['PRE']\n",
    "        elif epoch == 'MAZE':\n",
    "            x_start = max_num_windows_across_sessions[dataset_index]['PRE']\n",
    "            x_end = max_num_windows_across_sessions[dataset_index]['PRE'] + max_num_windows_across_sessions[dataset_index]['MAZE']\n",
    "        elif epoch == 'POST':\n",
    "            x_start = max_num_windows_across_sessions[dataset_index]['PRE'] + max_num_windows_across_sessions[dataset_index]['MAZE']\n",
    "            x_end = max_num_windows_across_sessions[dataset_index]['PRE'] + max_num_windows_across_sessions[dataset_index]['MAZE'] + max_num_windows_across_sessions[dataset_index]['POST']\n",
    "\n",
    "        epoch_bar_ax_bottom.axvspan(x_start, x_end, alpha=0.8, color=epoch_colors[epoch_index], linewidth= 0)\n",
    "        \n",
    "    epoch_bar_ax_bottom.set_xticks(axes_tick_mapping[:, 0], axes_tick_mapping[:, 1])\n",
    "    epoch_bar_ax_bottom.yaxis.set_visible(False)\n",
    "    epoch_bar_ax_bottom.spines['left'].set_visible(False)\n",
    "\n",
    "    epoch_bar_ax_bottom.set_xlabel('Time (hour)', fontsize=5, labelpad = 0)\n",
    "\n",
    "    epoch_bar_ax_bottom.tick_params(axis='both', which='major', length=1, pad=0.5, width=0.5, labelsize = 4)\n",
    "    \n",
    "    if dataset_index == 2:\n",
    "        corr_mat_ax.set_xlim([0, x_end])\n",
    "\n",
    "\n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    # Calculate the average LT stability in 2 hours moving blocks with 1 hour step sizes\n",
    "\n",
    "    ax2 = fig.add_subplot(gs[1])\n",
    "    # ax2.set_aspect('equal')\n",
    "    ax2.set_aspect(.3)\n",
    "\n",
    "\n",
    "    # if dataset_index == 1:\n",
    "    #     ax2.set_aspect('equal')\n",
    "    # else:\n",
    "    #     ax2.set_aspect(.5)\n",
    "\n",
    "\n",
    "    sleep_epoch_names = ['PRE', 'POST']\n",
    "    # z_score_stability_time_window_aligned[dataset_index] = dict.fromkeys(sleep_epoch_names)\n",
    "\n",
    "\n",
    "    window_centers_non_overlap = []\n",
    "    for epoch in epoch_names:\n",
    "        window_centers_non_overlap.append(moving_time_window_centers_aligned[dataset_index][epoch][::3])\n",
    "    window_centers_non_overlap = np.concatenate(window_centers_non_overlap, axis = 0)\n",
    "\n",
    "\n",
    "    PRE_start = moving_time_window_centers_aligned[dataset_index]['PRE'][0]\n",
    "    PRE_end = moving_time_window_centers_aligned[dataset_index]['PRE'][-1]\n",
    "\n",
    "    MAZE_start = moving_time_window_centers_aligned[dataset_index]['MAZE'][0]\n",
    "    MAZE_end = moving_time_window_centers_aligned[dataset_index]['MAZE'][-1]\n",
    "\n",
    "    POST_start = moving_time_window_centers_aligned[dataset_index]['POST'][0]\n",
    "    POST_end = moving_time_window_centers_aligned[dataset_index]['POST'][-1]\n",
    "\n",
    "    if dataset_index == 1:\n",
    "        POST_end -= 2\n",
    "    \n",
    "\n",
    "    median_stabilties_zscore = dict.fromkeys(['PRE', 'POST'])\n",
    "    median_stabilties_zscore['PRE'] = [None]*len(current_session_indexes)\n",
    "    median_stabilties_zscore['POST'] = [None]*len(current_session_indexes)\n",
    "\n",
    "    for session_idx_in_current_dataset, session_idx in enumerate(current_session_indexes):\n",
    "\n",
    "        # Data\n",
    "        curr_session_stability_data = moving_window_correlation_mat_data[session_idx]\n",
    "        curr_session_stability_data = curr_session_stability_data[::3, ::3, :]\n",
    "\n",
    "        total_num_nonoverlap_time_wins, _, curr_num_units = curr_session_stability_data.shape\n",
    "        \n",
    "        for unit in range(curr_num_units):\n",
    "            curr_mat = curr_session_stability_data[:, :, unit]\n",
    "            curr_mat[np.diag_indices(total_num_nonoverlap_time_wins)] = np.nan\n",
    "            curr_session_stability_data[:,:,unit] = curr_mat\n",
    "\n",
    "\n",
    "        # Shuffle\n",
    "        curr_session_stability_shuffle = moving_window_correlation_mat_ui[session_idx]\n",
    "        curr_session_stability_shuffle = curr_session_stability_shuffle[::3, ::3, :]\n",
    "\n",
    "        num_shuffles = curr_session_stability_shuffle.shape[2]\n",
    "        for shuffle_idx in range(num_shuffles):\n",
    "            current_mat = curr_session_stability_shuffle[:, :, shuffle_idx]\n",
    "            current_mat[np.diag_indices(total_num_nonoverlap_time_wins)] = np.nan\n",
    "            curr_session_stability_shuffle[:, :, shuffle_idx] = current_mat\n",
    "\n",
    "\n",
    "\n",
    "        # PRE\n",
    "        pre_start_index = np.argmax(window_centers_non_overlap >= PRE_start)\n",
    "        pre_end_index = np.argmax(window_centers_non_overlap >= MAZE_start)-1\n",
    "        \n",
    "        curr_epoch_corr_mat_data = curr_session_stability_data[pre_start_index:pre_end_index, pre_start_index:pre_end_index, :]\n",
    "        curr_epoch_corr_mat_shuffle = curr_session_stability_shuffle[pre_start_index:pre_end_index, pre_start_index:pre_end_index, :]\n",
    "\n",
    "        num_pre_time_wins = curr_epoch_corr_mat_data.shape[0]\n",
    "\n",
    "        median_stabilities_data = np.nanmedian(np.reshape(curr_epoch_corr_mat_data, (num_pre_time_wins**2, curr_num_units)), axis = 0)\n",
    "        median_stabilities_shuffle = np.nanmedian(np.reshape(curr_epoch_corr_mat_shuffle, (num_pre_time_wins**2, num_shuffles)), axis = 0)\n",
    "\n",
    "        median_stabilties_zscore['PRE'][session_idx_in_current_dataset] = (median_stabilities_data - np.nanmean(median_stabilities_shuffle))/np.nanstd(median_stabilities_shuffle)\n",
    "\n",
    "\n",
    "\n",
    "        # POST\n",
    "\n",
    "        block_start_times = np.arange(POST_start, POST_end, 1)\n",
    "        block_end_times = block_start_times + 2\n",
    "        num_blocks = block_start_times.shape[0]\n",
    "\n",
    "        median_stabilties_zscore['POST'][session_idx_in_current_dataset] = np.full((curr_num_units, num_blocks), np.nan)\n",
    "        \n",
    "        for block_index in range(num_blocks-1):\n",
    "            \n",
    "            curr_block_win_indexes = np.where((window_centers_non_overlap >= block_start_times[block_index]) & (window_centers_non_overlap < block_end_times[block_index]))[0]\n",
    "\n",
    "            curr_block_start_idx = curr_block_win_indexes[0]\n",
    "            curr_block_end_idx = curr_block_win_indexes[-1]\n",
    "            \n",
    "\n",
    "\n",
    "            curr_block_corr_mat_data = curr_session_stability_data[curr_block_start_idx:curr_block_end_idx, curr_block_start_idx:curr_block_end_idx, :]\n",
    "            curr_block_corr_mat_shuffle = curr_session_stability_shuffle[curr_block_start_idx:curr_block_end_idx, curr_block_start_idx:curr_block_end_idx, :]\n",
    "\n",
    "            num_curr_block_time_wins = curr_block_corr_mat_data.shape[0]\n",
    "\n",
    "\n",
    "            median_stabilities_data = np.nanmedian(np.reshape(curr_block_corr_mat_data, (num_curr_block_time_wins**2, curr_num_units)), axis = 0)\n",
    "            median_stabilities_shuffle = np.nanmedian(np.reshape(curr_block_corr_mat_shuffle, (num_curr_block_time_wins**2, num_shuffles)), axis = 0)\n",
    "\n",
    "            median_stabilties_zscore['POST'][session_idx_in_current_dataset][:, block_index] = (median_stabilities_data - np.nanmean(median_stabilities_shuffle))/np.nanstd(median_stabilities_shuffle)\n",
    "\n",
    "\n",
    "    pooled_data = {'PRE':None, 'POST':None}\n",
    "    for epoch in ['PRE', 'POST']:\n",
    "        pooled_data[epoch] = np.concatenate(median_stabilties_zscore[epoch], axis = 0)\n",
    "    \n",
    "    \n",
    "    num_columns = pooled_data['POST'].shape[1]\n",
    "    if num_columns < 9:\n",
    "        num_columns_2_add = 9-num_columns\n",
    "        pooled_data['POST'] = np.concatenate((pooled_data['POST'], np.full((pooled_data['POST'].shape[0], num_columns_2_add), np.nan)), axis = 1)\n",
    "\n",
    "    pooled_data_concatenated_PRE_POST = np.concatenate((pooled_data['PRE'].reshape(-1,1), pooled_data['POST']), axis = 1)\n",
    "\n",
    "\n",
    "    # vio = sns.violinplot(data = pooled_data_concatenated_PRE_POST, inner = 'quartile', cut = 0, color = 'gray', linewidth = 0, capstyle='butt', bw = 0.2, ax=ax2) \n",
    "    vio = sns.violinplot(data = pooled_data_concatenated_PRE_POST, inner = 'quartile', cut = 0, palette = [epoch_colors[0]] + [epoch_colors[2]]*8, linewidth = 0, capstyle='butt', bw = 0.2, ax=ax2) \n",
    "\n",
    "    for l in ax2.lines:\n",
    "        l.set_linestyle('-')\n",
    "        l.set_linewidth(0.25)\n",
    "        l.set_color('white')\n",
    "        l.set_alpha(1)\n",
    "    for l in ax2.lines[1::3]:\n",
    "        l.set_linestyle('-')\n",
    "        l.set_linewidth(0.5)\n",
    "        l.set_color('white')\n",
    "        l.set_alpha(1)\n",
    "    ax2.grid(axis='y', color=(0.7,0.7,0.7), linewidth=0.5)\n",
    "    for axis in ['left', 'bottom']:\n",
    "        ax2.spines[axis].set_linewidth(0.75)        \n",
    "\n",
    "    ax2.set_ylabel('LT stability (z)', fontsize=5, labelpad=1)\n",
    "    ax2.xaxis.set_visible(False)\n",
    "    ax2.spines['bottom'].set_visible(False)\n",
    "\n",
    "    ax2.set_ylim([-5, 20])\n",
    "    ax2.set_yticks([0, 5 , 10, 15])\n",
    "\n",
    "\n",
    "    # Measure statistical significance of differnece between the stability in each 2 hour block with the stability in the previous block\n",
    "    \n",
    "    num_columns = pooled_data_concatenated_PRE_POST.shape[1]\n",
    "    p_value_difference_with_previous_block = np.full((num_columns, ), np.nan)\n",
    "    for column_index in range(1, num_columns):\n",
    "        current_column = pooled_data_concatenated_PRE_POST[:, column_index]\n",
    "        previous_column = pooled_data_concatenated_PRE_POST[:, column_index-1]\n",
    "\n",
    "        vlaid_indexes = ~np.isnan(current_column) & ~np.isnan(previous_column)\n",
    "        _, p_value_difference_with_previous_block[column_index] = wilcoxon(current_column[vlaid_indexes], previous_column[vlaid_indexes])\n",
    "\n",
    "        ax2.text(column_index, 18, get_pval_statement(p_value_difference_with_previous_block[column_index]), fontsize = 2, color = 'black', ha='center', rotation = 90)\n",
    "\n",
    "\n",
    "\n",
    "    # ax2.set_yticks([0, 2])\n",
    "    ax2.tick_params(axis='both', which='major', length=1, pad=1, width=0.5, labelsize = 4)\n",
    "\n",
    "\n",
    "\n",
    "    plt.subplots_adjust(left=0.15, right= 0.95, bottom=0.05, top=1)\n",
    "\n",
    "    filename = f'{dataset_name}_moving_window_LT_averege_correlation_mat_each dataset_Fig4c.pdf'\n",
    "    file_path = os.path.join(data_dir, filename)\n",
    "    plt.savefig(file_path, dpi=300)\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 276,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_30485/195595171.py:101: RuntimeWarning: Mean of empty slice\n",
      "  curr_mean = np.nanmean(pooled_data[session_indexes], axis = 0)\n",
      "/tmp/ipykernel_30485/195595171.py:112: RuntimeWarning: Mean of empty slice\n",
      "  curr_mean = np.nanmean(pooled_data[session_indexes], axis = 0)\n",
      "/tmp/ipykernel_30485/195595171.py:90: RuntimeWarning: Mean of empty slice\n",
      "  curr_mean = np.nanmean(pooled_data[session_indexes], axis = 0)\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e84ab2d4e0d44c62bd630b184fe0b64b",
       "version_major": 2,
       "version_minor": 0
      },
      "image/png": "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",
      "text/html": [
       "\n",
       "            <div style=\"display: inline-block;\">\n",
       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
       "                    Figure\n",
       "                </div>\n",
       "                <img src='data:image/png;base64,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' width=263.88888888888886/>\n",
       "            </div>\n",
       "        "
      ],
      "text/plain": [
       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.ticker as ticker\n",
    "\n",
    "def remove_trailing_zeros(x, pos):\n",
    "    formatted_label = f\"{int(x):d}\" if x == int(x) else f\"{x:.1f}\"\n",
    "    return formatted_label\n",
    "\n",
    "#-----------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Set up figure colors and style\n",
    "\n",
    "sns.set_style('whitegrid') \n",
    "sns.set_context('paper')\n",
    "\n",
    "custom_params = {\n",
    "    \"axes.spines.top\": False,\n",
    "    \"axes.spines.right\": False\n",
    "    }\n",
    "\n",
    "sns.set_theme(style=\"ticks\", rc=custom_params)\n",
    "\n",
    "plt.rcParams.update({\n",
    "    'font.size':6,\n",
    "    'axes.linewidth':0.75,\n",
    "    'pdf.fonttype':42,\n",
    "    'ps.fonttype':42,\n",
    "    'axes.labelsize':6,\n",
    "    'axes.titlesize':6,\n",
    "    'xtick.labelsize':5,\n",
    "    'ytick.labelsize':5,\n",
    "    'legend.fontsize':6,\n",
    "    'legend.title_fontsize':6,\n",
    "    'legend.frameon': False,\n",
    "    'legend.markerscale':2,\n",
    "    'xtick.major.size':2,\n",
    "    'ytick.major.size':2\n",
    "})\n",
    "\n",
    "\n",
    "epoch_colors = [\n",
    "    '#005CE9', # PRE\n",
    "    'black', # MAZE\n",
    "    '#DD335D', # POST\n",
    "    ] \n",
    "\n",
    "dataset_specific_colors = [\"#E58044\", \"#046C7C\", \"#85459B\"] # , \n",
    "\n",
    "#-------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Generate the figure\n",
    "\n",
    "\n",
    "plotheight = 60\n",
    "plotwidth = 190\n",
    "font_size = 5\n",
    "\n",
    "fig = plt.figure()\n",
    "fig.set_size_inches([plotwidth/72, plotheight/72])\n",
    "gs = GridSpec(nrows=2, ncols=1, height_ratios=[0.03, 1], figure=fig, hspace=0.0, wspace=2)\n",
    "\n",
    "\n",
    "\n",
    "#--------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Plot the LT fidelity across time\n",
    "ax1 = fig.add_subplot(gs[1])\n",
    "\n",
    "ax1.axhline(y = 0, linewidth = 0.5, linestyle = '--', color = (.2,.2,.2), alpha = 0.6)\n",
    "\n",
    "\n",
    "for epoch_index, epoch in enumerate(epoch_names):\n",
    "\n",
    "    win_centers = moving_time_window_centers_aligned[3][epoch]\n",
    "    \n",
    "    for session_idx in range(number_of_sessions):\n",
    "        session_number = included_session_IDX[session_idx]\n",
    "        if session_number in range(5):\n",
    "            color = dataset_specific_colors[0]\n",
    "        elif session_number in range(6,11):\n",
    "            color = dataset_specific_colors[1]\n",
    "        else:\n",
    "            color = dataset_specific_colors[2]\n",
    "\n",
    "        ax1.plot(win_centers, moving_window_LT_fidelities_time_windows_aligned[epoch][session_idx], color = color, linewidth = 0.25, alpha = 0.4)\n",
    "\n",
    "    \n",
    "    pooled_data = np.concatenate(moving_window_LT_fidelities_time_windows_aligned[epoch], axis = 0).reshape(-1, max_num_windows_across_sessions[3][epoch])\n",
    "\n",
    "\n",
    "\n",
    "    ## Only Grosmark dataset sessions\n",
    "    session_indexes = np.arange(5)\n",
    " \n",
    "    curr_mean = np.nanmean(pooled_data[session_indexes], axis = 0)\n",
    "    curr_error = np.nanstd(pooled_data[session_indexes], axis = 0)/session_indexes.shape[0]\n",
    "    \n",
    "    label = 'Grosmark dataset' if epoch_index ==0 else ''\n",
    "    ax1.plot(win_centers, curr_mean, color = dataset_specific_colors[0], linewidth = 0.5, alpha = 0.8, label = label)\n",
    "    ax1.fill_between(win_centers, curr_mean-curr_error, curr_mean+curr_error, color = dataset_specific_colors[0], alpha = 0.3, linewidth = 0)\n",
    "\n",
    "\n",
    "\n",
    "    ## Only Giri dataset sessions\n",
    "    session_indexes = np.arange(6,11)\n",
    "\n",
    "    curr_mean = np.nanmean(pooled_data[session_indexes], axis = 0)\n",
    "    curr_error = np.nanstd(pooled_data[session_indexes], axis = 0)/session_indexes.shape[0]\n",
    "\n",
    "    label = 'Giri dataset' if epoch_index ==0 else ''\n",
    "    ax1.plot(win_centers, curr_mean, color = dataset_specific_colors[1], linewidth = 0.5, alpha = 0.8, label = label)\n",
    "    ax1.fill_between(win_centers, curr_mean-curr_error, curr_mean+curr_error, color = dataset_specific_colors[1], alpha = 0.3, linewidth = 0)\n",
    "\n",
    "\n",
    "\n",
    "    ## Only Miyawaki dataset session\n",
    "    session_indexes = np.arange(11,15)\n",
    "    session_indexes = np.append(session_indexes, 5)\n",
    "\n",
    "    curr_mean = np.nanmean(pooled_data[session_indexes], axis = 0)\n",
    "    curr_error = np.nanstd(pooled_data[session_indexes], axis = 0)/session_indexes.shape[0]\n",
    "\n",
    "    label = 'Miyawaki' if epoch_index ==0 else ''\n",
    "    ax1.plot(win_centers, curr_mean, color = dataset_specific_colors[2], linewidth = 0.5, alpha = 0.8, label = label)\n",
    "    ax1.fill_between(win_centers, curr_mean-curr_error, curr_mean+curr_error, color = dataset_specific_colors[2], alpha = 0.3, linewidth = 0)\n",
    "\n",
    "\n",
    "    ## all sessions\n",
    "    curr_mean = np.nanmean(pooled_data, axis = 0)\n",
    "    curr_error = np.nanstd(pooled_data, axis = 0)/number_of_sessions\n",
    "\n",
    "    ax1.plot(win_centers, curr_mean, color = (.2,.2,.2), linewidth = 0.5, alpha = 0.8)\n",
    "    ax1.fill_between(win_centers, curr_mean-curr_error, curr_mean+curr_error, color = (.2,.2,.2), alpha = 0.3, linewidth = 0)\n",
    "\n",
    "ax1.legend(fontsize = 4, loc='upper right',bbox_to_anchor=(1.05, 1))\n",
    "\n",
    "old_xlim = ax1.get_xlim()\n",
    "ax1.set_xlim([0, old_xlim[1]-2.8])\n",
    "\n",
    "x_axis_mapping = [\n",
    "    [moving_time_window_centers_aligned[3]['PRE'][-1]-4, -4],\n",
    "    [moving_time_window_centers_aligned[3]['PRE'][-1]-2, -2],\n",
    "    [moving_time_window_centers_aligned[3]['PRE'][-1], 0],\n",
    "    [moving_time_window_centers_aligned[3]['MAZE'][0]+2, 2],\n",
    "    [moving_time_window_centers_aligned[3]['POST'][0], 0],\n",
    "    [moving_time_window_centers_aligned[3]['POST'][0]+2, 2],\n",
    "    [moving_time_window_centers_aligned[3]['POST'][0]+4, 4],\n",
    "    [moving_time_window_centers_aligned[3]['POST'][0]+6, 6],\n",
    "    [moving_time_window_centers_aligned[3]['POST'][0]+8, 8],\n",
    "    ]\n",
    "x_axis_mapping = np.array(x_axis_mapping)\n",
    "\n",
    "ax1.set_xticks(np.double(x_axis_mapping[:, 0]), x_axis_mapping[:, 1].astype(int))\n",
    "ax1.set_yticks([0, 5, 10, 15])\n",
    "# ax1.grid(axis='y', color=(.8,.8,.8), linewidth=0.5)\n",
    "\n",
    "\n",
    "ax1.set_xlabel('Time (hour)', labelpad = 0)\n",
    "ax1.set_ylabel('PF fidelity (z)', fontsize = 6, labelpad = 0)\n",
    "\n",
    "\n",
    "ax1.tick_params(axis='both', which='major', length=1, pad=1, width=1)\n",
    "\n",
    "\n",
    "\n",
    "#------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Epoch time span indicator bars\n",
    "\n",
    "ax0 = fig.add_subplot(gs[0], sharex = ax1)\n",
    "\n",
    "for epoch_index, epoch in enumerate(epoch_names):\n",
    "\n",
    "    win_centers = moving_time_window_centers_aligned[3][epoch]\n",
    "    ax0.axvspan(win_centers[0], win_centers[-1], alpha=0.8, color=epoch_colors[epoch_index], linewidth= 0)\n",
    "    ax0.text(np.mean(win_centers), 1.5, epoch, fontsize=6, ha='center', color=epoch_colors[epoch_index], alpha=0.8)\n",
    "ax0.axis('off')\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "plt.subplots_adjust(left=0.1, right= 0.95, bottom=0.25, top=0.90)\n",
    "\n",
    "\n",
    "filename = 'PF fidelity_over_time.pdf'\n",
    "file_path = os.path.join(data_dir, filename)\n",
    "# plt.savefig(file_path, dpi=300)\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot the moving-window learned tunings for an example session\n",
    "\n",
    "#### The following sections are mainly for figure 5, where moving window learned tuning is calculated for the whole POST period and compared against reMAZE place field\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "sample_session_index = 8\n",
    "\n",
    "\n",
    "\n",
    "data_dir = r'/home/kouroshmaboudi/Documents/Learned_tuning_Python/Datasets'\n",
    "sessions = [d for d in os.listdir(data_dir) if os.path.isdir(os.path.join(data_dir, d))]\n",
    "\n",
    "session_name = sessions[sample_session_index]\n",
    "\n",
    "session_dataset_path = os.path.join(data_dir, session_name)\n",
    "\n",
    "filename = f'{session_name}.learned_tunings_vs_time_all_offline.npy'\n",
    "file_path = os.path.join(session_dataset_path, filename)\n",
    "    \n",
    "learned_tunings_vs_time_all_offline = np.load(file_path, allow_pickle = True).item()\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# Rat U\n",
    "# units_to_plot = np.array([25, 87, 23, 40]) # Rat U - all units that I found\n",
    "# units_to_plot = np.array([25, 87, 40]) # Rat U - the unit that will be included in the main figure\n",
    "# units_to_plot = np.array([130, 49, 52, 37, 110, 0, 152, 14, 99]) # Rat U from figure 5e-bottom\n",
    "# units_to_plot = np.array([13, 164, 127, 31,149, 16, 136, 32,61, 137, 115, 67, 19]) # Rat U from figure5e_bottom\n",
    "units_to_plot = np.arange(80, 100)\n",
    "\n",
    "# Rat V-Day1 Linear\n",
    "# units_to_plot = np.array([18]) # Rat V-Day 1 Linear \n",
    "# units_to_plot = np.array([11, 31, 35]) # Rat V-Day1 Linear from figure 5e\n",
    "\n",
    "\n",
    "# Rat V-Day 3 Semi-circular\n",
    "# units_to_plot = np.array([37, 48, 8, 57]) # Rat V-Day 3 Semi-circular - all units that I found\n",
    "# units_to_plot = np.array([57]) # the unit that will be included in the main figure\n",
    "# units_to_plot = np.array([63, 66]) # Rat V-Day 3 gradual drift\n",
    "\n",
    "# ---------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Define functions\n",
    "\n",
    "def max_normalize_columns(matrix):\n",
    "    \"\"\"\n",
    "    Takes a matrix as input and returns a new matrix where each column sums up to one (a probability distribution)\n",
    "    \"\"\"\n",
    "    # calculate the sum of each column\n",
    "    col_max = np.max(matrix, axis=0)\n",
    "    \n",
    "    # divide each element in a column by its sum\n",
    "    normalized_matrix = matrix / col_max[np.newaxis, :]\n",
    "    \n",
    "    return normalized_matrix\n",
    "\n",
    "\n",
    "#-----------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Set up figure colors and style\n",
    "\n",
    "sns.set_style('whitegrid') # Set style and context\n",
    "sns.set_context('paper')\n",
    "\n",
    "custom_params = {\"axes.spines.top\": False, \"axes.spines.right\": False}\n",
    "sns.set_theme(style=\"ticks\", rc=custom_params)\n",
    "\n",
    "plt.rcParams.update({\n",
    "    'font.size':5,\n",
    "    'axes.linewidth':1,\n",
    "    'pdf.fonttype':42,\n",
    "    'ps.fonttype':42,\n",
    "    'axes.labelsize':6,\n",
    "    'axes.titlesize':6,\n",
    "    'xtick.labelsize':5,\n",
    "    'ytick.labelsize':5,\n",
    "    'legend.fontsize':5,\n",
    "    'legend.title_fontsize':6,\n",
    "    'legend.frameon': False,\n",
    "    'legend.markerscale':2,\n",
    "    'xtick.major.size':2,\n",
    "    'ytick.major.size':2\n",
    "})\n",
    "\n",
    "epoch_colors = [\n",
    "    '#005CE9', # PRE\n",
    "    'black', # MAZE\n",
    "    '#DD335D', # POST\n",
    "    '#DC9A5D', # late POST\n",
    "    ] \n",
    "\n",
    "\n",
    "# tunings_to_plot_names = ['maze_theta', 'MAZE', 'spatial_tunings_maze', 'POST', 'spatial_tunings_remaze']\n",
    "# tunings_to_plot_names = ['spatial_tunings_maze', 'PRE', 'POST', 'latePOST', 'spatial_tunings_remaze']\n",
    "tunings_to_plot_names = ['spatial_tunings_maze']\n",
    "\n",
    "# colors for the LTs and PFs\n",
    "tuning_colors = dict()\n",
    "tuning_colors['spatial_tunings_maze'] = [0.1490, 0.1490,  0.1490]\n",
    "tuning_colors['PRE'] = '#005CE9'\n",
    "# tuning_colors['maze_theta'] = [0.2039, 0.3843, 0.1882]\n",
    "# tuning_colors['MAZE'] = [0.0627, 0.5451, 0.2667]\n",
    "tuning_colors['POST'] = '#DC335D'\n",
    "tuning_colors['latePOST'] = '#DC9A5D'\n",
    "tuning_colors['spatial_tunings_remaze'] = [0.1490, 0.1490,  0.1490]\n",
    "\n",
    "# offsets for plotting the tuning curves next to each other  \n",
    "tuning_x_offsets = dict()\n",
    "tuning_x_offsets['spatial_tunings_maze'] = 0\n",
    "tuning_x_offsets['PRE'] = 1\n",
    "# tuning_x_offsets['maze_theta']\n",
    "# tuning_x_offsets['MAZE']\n",
    "tuning_x_offsets['POST'] = 2\n",
    "tuning_x_offsets['latePOST'] = 3\n",
    "tuning_x_offsets['spatial_tunings_remaze'] = 4\n",
    "\n",
    "\n",
    "\n",
    "#-------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Generate the figure\n",
    "\n",
    "# Create figure and subplots\n",
    "# plotheight = 1.08\n",
    "plotheight = 15\n",
    "plotwidth = 5\n",
    "font_size = 6\n",
    "\n",
    "\n",
    "fig = plt.figure()\n",
    "fig.set_size_inches([plotwidth, plotheight])\n",
    "gs = GridSpec(nrows=2+units_to_plot.shape[0], ncols=2, figure=fig, width_ratios=[1, 0.2], height_ratios = [.1, .5]+[1]*units_to_plot.shape[0], hspace=0.3, wspace=0.02)\n",
    "\n",
    "\n",
    "epochs_time_span_in_hours = epochs[sample_session_index]/3600\n",
    "\n",
    "t_start = learned_tunings_vs_time_all_offline['PRE']['win_centers'][0]/3600\n",
    "t_end   = learned_tunings_vs_time_all_offline['POST']['win_centers'][-1]/3600\n",
    "\n",
    "\n",
    "#------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Brain state indicator bars\n",
    "\n",
    "ax1 = fig.add_subplot(gs[1, 0])\n",
    "\n",
    "ax1.imshow(time_bin_brain_state_2D_array[sample_session_index], extent = [time_bins_centers[sample_session_index][0]/3600, time_bins_centers[sample_session_index][-1]/3600, 0, 4], interpolation='nearest', cmap='binary', origin='lower')\n",
    "ax1.set_aspect(\"auto\")\n",
    "\n",
    "# ax1.axis('off')\n",
    "ax1.set_xlim([0, t_end])\n",
    "ax1.tick_params(axis='both', which='major', labelsize=5, width=1)\n",
    "ax1.set_yticks(np.array([1,2,3,4])-0.5,  brainStates_names, fontsize= 4)\n",
    "ax1.spines['bottom'].set_visible(False)\n",
    "ax1.spines['left'].set_visible(False)\n",
    "ax1.set_xticks([])\n",
    "ax1.tick_params(axis='both', which='both', length=0, pad=2)\n",
    "\n",
    "\n",
    "#------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Epoch time span indicator bars\n",
    "\n",
    "ax0 = fig.add_subplot(gs[0, 0], sharex = ax1)\n",
    "\n",
    "epochs_time_span_in_hours_including_latePOST = np.concatenate((epochs_time_span_in_hours, np.zeros((1, 2))), axis=0 )\n",
    "epochs_time_span_in_hours_including_latePOST[2,1] = epochs_time_span_in_hours[2,0] + 4\n",
    "epochs_time_span_in_hours_including_latePOST[3,0] = epochs_time_span_in_hours[2,0] + 4\n",
    "epochs_time_span_in_hours_including_latePOST[3,1] = epochs_time_span_in_hours[2,1]\n",
    "\n",
    "epochs_plus_latePOST = ['PRE', 'MAZE', 'POST', 'late POST']\n",
    "\n",
    "for epoch_index, epoch in enumerate(epochs_plus_latePOST):\n",
    "    start,end = epochs_time_span_in_hours_including_latePOST[epoch_index]\n",
    "    ax0.axvspan(start, end-0.02, alpha=0.8, color=epoch_colors[epoch_index], linewidth= 0)\n",
    "    ax0.text(np.mean(epochs_time_span_in_hours_including_latePOST[epoch_index]), 1.3, epoch, fontsize=6, ha='center', color=epoch_colors[epoch_index], alpha=0.8)\n",
    "ax0.axis('off')\n",
    "ax0.set_xlim([0, t_end])\n",
    "\n",
    "\n",
    "\n",
    "#---------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Moving-window LTs \n",
    "\n",
    "ax_start_index = 2\n",
    "for unit_index, unit in enumerate(units_to_plot):\n",
    "    \n",
    "    #------------------------------------------------------------------------------\n",
    "    # Left panels: Learned tunings in 15 minutes time windows for the current unit\n",
    "\n",
    "    ax2 = fig.add_subplot(gs[unit_index + ax_start_index, 0])\n",
    "\n",
    "    for j, epoch in enumerate(epoch_names):\n",
    "\n",
    "        LTs = learned_tunings_vs_time_all_offline[epoch]['learned_tunings_all_offline_across_time'][unit, :, :]\n",
    "        LTs = max_normalize_columns(LTs)\n",
    "        LTs[np.isnan(LTs)] = 0\n",
    "\n",
    "        if (unit_index == 0) & (j==0):\n",
    "            num_pos_bins = LTs.shape[0]\n",
    "        \n",
    "        ax2.imshow(LTs, extent = [epochs_time_span_in_hours[j, 0], epochs_time_span_in_hours[j, 1], 0, num_pos_bins], interpolation='nearest', origin = 'lower', cmap='inferno', label=epoch) \n",
    "\n",
    "\n",
    "    ax2.set_xlim([0, t_end])\n",
    "    ax2.set_title(f\"unit {unit}\", loc = 'left', fontsize= 5, y=0.75)\n",
    "    ax2.set_aspect(\"auto\")\n",
    "    \n",
    "    ax2.axvline(x = epochs_time_span_in_hours[1, 0], color='white', linestyle='--', linewidth=0.5)\n",
    "    ax2.axvline(x = epochs_time_span_in_hours[1, 1], color='white', linestyle='--', linewidth=0.5)\n",
    "\n",
    "    ax2.set_xticks(np.arange(0, t_end, 2))\n",
    "    if unit_index == (units_to_plot.shape[0]-1):\n",
    "        ax2.set_xlabel('Time(h)', labelpad=0)\n",
    "    else:\n",
    "        ax2.set_xticklabels('')\n",
    "    \n",
    "    ax2.set_yticks([0, num_pos_bins], [0, 1])\n",
    "    ax2.set_ylabel('Position', fontsize=5, labelpad=0)\n",
    "    ax2.tick_params(axis='both', which='major', labelsize=5, length=2, width=1, pad=1)\n",
    "\n",
    "    \n",
    "    # #------------------------------------------------------------------------------------\n",
    "    # # Right Panels: MAZE theta and ripple learned tunings, MAZE PF, POST LT and reMAZE PF\n",
    "\n",
    "    ax3 = fig.add_subplot(gs[unit_index+ax_start_index, 1])\n",
    "\n",
    "    for tuning_index, tuning_name in  enumerate(tunings_to_plot_names):\n",
    "        if tuning_name in learned_tunings:\n",
    "            current_tuning = learned_tunings[tuning_name][unit]          \n",
    "        else: # place fields, maze and remaze\n",
    "            current_tuning = spatial_tunings_maze[sample_session_index][unit]\n",
    "            # current_tuning = locals()[tuning_name][unit]\n",
    "\n",
    "        if np.all(current_tuning == 0):\n",
    "            ax3.plot(tuning_x_offsets[tuning_name]+current_tuning, np.arange(num_pos_bins), color = tuning_colors[tuning_name], linewidth=0.5, linestyle='--')\n",
    "        else:    \n",
    "            current_tuning = current_tuning/np.max(current_tuning)\n",
    "            current_tuning = current_tuning - np.nanmin(current_tuning)\n",
    "            ax3.plot(tuning_x_offsets[tuning_name]+current_tuning, np.arange(num_pos_bins), color = tuning_colors[tuning_name], linewidth=0.5, alpha= 0.9)\n",
    "            \n",
    "            x_left = tuning_x_offsets[tuning_name]\n",
    "            x_right = current_tuning + tuning_x_offsets[tuning_name]\n",
    "            \n",
    "            ax3.fill_betweenx(np.arange(num_pos_bins), x_left, x_right, alpha=0.4, color = tuning_colors[tuning_name], linewidth=0)\n",
    "\n",
    "    ax3.set_ylim([0, num_pos_bins])\n",
    "    ax3.set_yticks([0, num_pos_bins], [])\n",
    "    \n",
    "    ax3.set_xlim([-0.1, 6])\n",
    "\n",
    "    if unit_index == 0:\n",
    "        ax3.set_xticks(np.arange(0,5))\n",
    "        # ax3.set_xticklabels(['MAZE theta LT', 'MAZE ripple LT', 'MAZE PF', 'POST LT (early)', 'reMAZE PF'], rotation = 45)\n",
    "        \n",
    "        ax3.xaxis.tick_top()\n",
    "        ax3.xaxis.set_label_position('top')\n",
    "        ax3.set_xticklabels(['MAZE PF', 'PRE LT', 'POST LT', 'late POST LT', 'reMAZE PF'], rotation = 45, ha = 'left')\n",
    "        ax3.spines['left'].set_visible(False)\n",
    "        ax3.spines['bottom'].set_visible(False)\n",
    "        \n",
    "        cl = list(tuning_colors.values())\n",
    "        for label_index, label in enumerate(ax3.get_xticklabels()):\n",
    "            label.set_color(cl[label_index])\n",
    "\n",
    "    else:\n",
    "        ax3.axis('off')\n",
    "        ax3.set_xticklabels('')\n",
    "\n",
    "    ax3.tick_params(axis='both', which='both', length=0, pad=0)\n",
    "\n",
    "    \n",
    "\n",
    "\n",
    "\n",
    "# Adjust the subplots\n",
    "\n",
    "plt.subplots_adjust(left=0.2, right= 0.85, bottom=0.20, top=0.9, hspace=0.1)\n",
    "\n",
    "\n",
    "\n",
    "plt.subplots_adjust(hspace=0.5)\n",
    "plt.show()\n",
    "\n",
    "\n",
    "filename = f'{session_name}.test.pdf'\n",
    "file_path = os.path.join(session_dataset_path, filename)\n",
    "plt.savefig(file_path, dpi=300)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NREM- or QW-exclusive moving-window learned tunings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# ---------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Define functions\n",
    "\n",
    "def max_normalize_columns(matrix):\n",
    "    \"\"\"\n",
    "    Takes a matrix as input and returns a new matrix where each column sums up to one (a probability distribution)\n",
    "    \"\"\"\n",
    "    # calculate the sum of each column\n",
    "    col_max = np.max(matrix, axis=0)\n",
    "    \n",
    "    # divide each element in a column by its sum\n",
    "    normalized_matrix = matrix / col_max[np.newaxis, :]\n",
    "    \n",
    "    return normalized_matrix\n",
    "\n",
    "\n",
    "#-----------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Set up figure epoch_colors and style\n",
    "\n",
    "sns.set_style('whitegrid') # Set style and context\n",
    "sns.set_context('paper')\n",
    "\n",
    "custom_params = {\"axes.spines.top\": False, \"axes.spines.right\": False}\n",
    "sns.set_theme(style=\"ticks\", rc=custom_params)\n",
    "\n",
    "plt.rcParams.update({\n",
    "    'font.size':5,\n",
    "    'axes.linewidth':1,\n",
    "    'pdf.fonttype':42,\n",
    "    'ps.fonttype':42,\n",
    "    'axes.labelsize':6,\n",
    "    'axes.titlesize':6,\n",
    "    'xtick.labelsize':5,\n",
    "    'ytick.labelsize':5,\n",
    "    'legend.fontsize':5,\n",
    "    'legend.title_fontsize':6,\n",
    "    'legend.frameon': False,\n",
    "    'legend.markerscale':2,\n",
    "    'xtick.major.size':2,\n",
    "    'ytick.major.size':2\n",
    "})\n",
    "\n",
    "epoch_colors = [\n",
    "    '#005CE9', # PRE\n",
    "    'black', # MAZE\n",
    "    '#DD335D', # POST\n",
    "    ''\n",
    "    ] \n",
    "\n",
    "\n",
    "#-------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Generate the figure\n",
    "\n",
    "# Create figure and subplots\n",
    "plotheight = 5\n",
    "plotwidth = 5\n",
    "font_size = 6\n",
    "\n",
    "\n",
    "fig = plt.figure()\n",
    "fig.set_size_inches([plotwidth, plotheight])\n",
    "gs = GridSpec(nrows=units_to_plot.shape[0]+2, ncols=1, figure=fig, width_ratios=[1], height_ratios = [.1, .3]+[1]*units_to_plot.shape[0], hspace=0.3, wspace=0.2)\n",
    "\n",
    "#---------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Moving-window LTs \n",
    "\n",
    "\n",
    "epochs_time_span_in_hours = epochs/3600\n",
    "\n",
    "\n",
    "t_start = learned_tunings_vs_time_NREM_vs_QW['PRE']['win_centers'][0]/3600\n",
    "t_end   = learned_tunings_vs_time_NREM_vs_QW['POST']['win_centers'][-1]/3600\n",
    "\n",
    "\n",
    "ax_start_index = 2\n",
    "for unit_index, unit in enumerate(units_to_plot):\n",
    "\n",
    "    ax2 = fig.add_subplot(gs[unit_index + ax_start_index])\n",
    "\n",
    "    for j, epoch in enumerate(epoch_names):\n",
    "\n",
    "        NREM_LT = learned_tunings_vs_time_NREM_vs_QW[epoch]['learned_tunings_NREM_across_time'][unit, :, :]\n",
    "        NREM_LT = max_normalize_columns(NREM_LT) # divide each column by its maximum value\n",
    "\n",
    "        QW_LT = learned_tunings_vs_time_NREM_vs_QW[epoch]['learned_tunings_QW_across_time'][unit, :, :]\n",
    "        QW_LT = max_normalize_columns(QW_LT)\n",
    "\n",
    "        LT = np.concatenate([QW_LT, NREM_LT], axis=0) # concatenate the NREM and QW learned tunings along position dimension in order to plot them together\n",
    "\n",
    "        ax2.imshow(LT, extent = [epochs_time_span_in_hours[j, 0], epochs_time_span_in_hours[j, 1], 0, num_pos_bins*2], interpolation='nearest', origin = 'lower', cmap='inferno', label=epoch) \n",
    "\n",
    "    ax2.set_xlim([0, t_end])\n",
    "    ax2.set_title(f\"unit {unit}\", loc = 'left', fontsize= 5, y=0.92)\n",
    "    ax2.set_aspect(\"auto\")\n",
    "    ax2.tick_params(axis='both', which='major', labelsize=5)\n",
    "    ax2.axhline(y = num_pos_bins, color='white', linestyle='--', linewidth=0.5)\n",
    "    ax2.axvline(x = epochs_time_span_in_hours[1, 0], color='gray', linestyle='-', linewidth=0.5)\n",
    "    ax2.axvline(x = epochs_time_span_in_hours[1, 1], color='gray', linestyle='-', linewidth=0.5)\n",
    "\n",
    "    if unit_index == 0:\n",
    "        ax2.text(-1.5, 0.4*num_pos_bins, 'QW:', fontsize=6, ha = 'left', color='black', alpha = 0.8)\n",
    "        ax2.text(-1.5, 1.4*num_pos_bins, 'NREM:', fontsize=6, ha = 'left', color='black', alpha = 0.8)\n",
    "\n",
    "    ax2.set_xticks(np.arange(0, t_end, 2))\n",
    "    if unit_index == (units_to_plot.shape[0]-1):\n",
    "        ax2.set_xlabel('Time(h)')\n",
    "    else:\n",
    "        ax2.set_xticklabels('')\n",
    "    \n",
    "    ax2.set_yticks([0, num_pos_bins, num_pos_bins*2], [0, '0\\n1', 1])\n",
    "    ax2.set_ylabel('position', fontsize=6)\n",
    "\n",
    "#------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Brain state indicator bars\n",
    "\n",
    "ax1 = fig.add_subplot(gs[1])\n",
    "\n",
    "ax1.imshow(time_bin_brain_state_2D_array, extent = [time_bins_centers[0]/3600, time_bins_centers[-1]/3600, 0, 4], interpolation='nearest', cmap='binary', origin='lower')\n",
    "ax1.set_aspect(\"auto\")\n",
    "\n",
    "# ax1.axis('off')\n",
    "ax1.set_xlim([0, t_end])\n",
    "ax1.tick_params(axis='both', which='major', labelsize=5)\n",
    "ax1.set_yticks(np.array([1,2,3,4])-0.5,  brainStates_names, fontsize= 4)\n",
    "ax1.spines['bottom'].set_visible(False)\n",
    "ax1.set_xticks([])\n",
    "\n",
    "\n",
    "# # plot brain states based on Bapun's calculations\n",
    "# for bout_idx in range(bout_labels_Bapun.shape[0]):\n",
    "#     axes[2].barh(y = bout_labels_Bapun[bout_idx], left=bouts_start_bapun[bout_idx], width = bouts_end_bapun[bout_idx]-bouts_start_bapun[bout_idx], height=1, color=epoch_colors[bout_labels_Bapun[bout_idx]-1]) #\n",
    "# # axes[1].axis('off')\n",
    "# axes[2].set_yticks([1,2,3,4],  brainStates_names)\n",
    "# axes[2].tick_params(axis='both', which='major', labelsize=5)\n",
    "\n",
    "#------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Brain state indicator bars\n",
    "\n",
    "ax1 = fig.add_subplot(gs[1])\n",
    "\n",
    "ax1.imshow(time_bin_brain_state_2D_array, extent = [time_bins_centers[0]/3600, time_bins_centers[-1]/3600, 0, 4], interpolation='nearest', cmap='binary', origin='lower')\n",
    "ax1.set_aspect(\"auto\")\n",
    "\n",
    "# ax1.axis('off')\n",
    "ax1.set_xlim([0, t_end])\n",
    "ax1.tick_params(axis='both', which='major', labelsize=5)\n",
    "ax1.set_yticks(np.array([1,2,3,4])-0.5,  brainStates_names, fontsize= 4)\n",
    "ax1.spines['bottom'].set_visible(False)\n",
    "ax1.set_xticks([])\n",
    "\n",
    "\n",
    "# # plot brain states based on Bapun's calculations\n",
    "# for bout_idx in range(bout_labels_Bapun.shape[0]):\n",
    "#     axes[2].barh(y = bout_labels_Bapun[bout_idx], left=bouts_start_bapun[bout_idx], width = bouts_end_bapun[bout_idx]-bouts_start_bapun[bout_idx], height=1, color=epoch_colors[bout_labels_Bapun[bout_idx]-1]) #\n",
    "# # axes[1].axis('off')\n",
    "# axes[2].set_yticks([1,2,3,4],  brainStates_names)\n",
    "# axes[2].tick_params(axis='both', which='major', labelsize=5)\n",
    "\n",
    "\n",
    "\n",
    "#------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Epoch time span indicator bars\n",
    "\n",
    "ax0 = fig.add_subplot(gs[0], sharex = ax1)\n",
    "\n",
    "for epoch_index, epoch in enumerate(epoch_names):\n",
    "    start,end = epochs_time_span_in_hours[epoch_index]\n",
    "    ax0.axvspan(start, end-0.05, alpha=0.8, color=epoch_colors[epoch_index], )\n",
    "    ax0.text(np.mean(epochs_time_span_in_hours[epoch_index]), 1.3, epoch, fontsize=8, ha='center', color=epoch_colors[epoch_index], alpha=0.8)\n",
    "ax0.axis('off')\n",
    "\n",
    "\n",
    "#------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "# Epoch time span indicator bars\n",
    "\n",
    "ax0 = fig.add_subplot(gs[0], sharex = ax1)\n",
    "\n",
    "for epoch_index, epoch in enumerate(epoch_names):\n",
    "    start,end = epochs_time_span_in_hours[epoch_index]\n",
    "    ax0.axvspan(start, end-0.05, alpha=0.8, color=epoch_colors[epoch_index], )\n",
    "    ax0.text(np.mean(epochs_time_span_in_hours[epoch_index]), 1.3, epoch, fontsize=8, ha='center', color=epoch_colors[epoch_index], alpha=0.8)\n",
    "ax0.axis('off')\n",
    "\n",
    "\n",
    "\n",
    "# Adjust the subplots\n",
    "\n",
    "plt.subplots_adjust(left=0.2, right= 0.85, bottom=0.20, top=0.9, hspace=0.1)\n",
    "\n",
    "\n",
    "# plt.tight_layout()\n",
    "\n",
    "plt.show()\n",
    "\n",
    "filename = f'{session_name}.QW_NREM_learned_tuning_vs_time_2.svg'\n",
    "file_path = os.path.join(session_dataset_path, filename)\n",
    "plt.savefig(file_path, dpi=300)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}