From 43f98550fb7274df547180eae93719c6f587b58a Mon Sep 17 00:00:00 2001 From: KimYeerim <150426034+KimYeerim@users.noreply.github.com> Date: Thu, 22 Feb 2024 18:18:22 +0900 Subject: [PATCH 1/3] Add files via upload --- docs/projects/illusion.ipynb | 1212 +++++++++++++++++++++++++++++++++- 1 file changed, 1211 insertions(+), 1 deletion(-) diff --git a/docs/projects/illusion.ipynb b/docs/projects/illusion.ipynb index ea34ed78..98f2bffa 100644 --- a/docs/projects/illusion.ipynb +++ b/docs/projects/illusion.ipynb @@ -2892,6 +2892,1216 @@ "\n", "display_rfs(opto_rfs)" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# OpenScope Illusion Dataset: Example Analysis Code\n", + "\n", + "Please refer to the following preprint for a more detailed description of the dataset:\n", + "Shin et al., 2023 bioRxiv https://www.biorxiv.org/content/10.1101/2023.06.05.543698v1 \n", + "Recurrent pattern completion drives the neocortical representation of sensory inference\n", + "\n", + "In the aforementioned paper, we utilize illusory contours to study the neocortical mechanisms of sensory inference.\n", + "One of the datasets presented in the paper is the multi-Neuropixels recordings collected via the Allen Institute OpenScope collaboration.\n", + "\n", + "This code aims to serve as an example for analyzing the publicly available Openscope Illusion dataset.\n", + "Here, we are reproducing Fig 1d-g of Shin et al., 2023, where we show that mouse primary visual cortex (V1) neurons respond to illusory contours despite the lack of visual information within their receptive fields.\n", + "von der Heydt and colleagues showed this in primate visual cortex (von der Heydt et al., 1984; Peterhans & von der Heydt 1989).\n", + "We are replicating this result in mouse V1.\n", + "\n", + "Note, in our paper, we imposed a fixed-gaze restriction; i.e., only the trials where the pupil position was within 8 visual degrees of the resting pupil position throughout the duration of the trial was analyzed. For simplicity, we did not include this condition in this example code.\n", + "\n", + "This code was written by Yeerim Kim, with advice from Hyeyoung Shin. \n", + "Correspondence: Hyeyoung Shin (shinehyeyoung@gmail.com)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.patches as patches\n", + "import numpy as np\n", + "import pandas as pd\n", + "from pynwb import NWBHDF5IO\n", + "import scipy.stats as stats\n", + "from scipy.stats import kruskal, friedmanchisquare, wilcoxon, norm\n", + "from statsmodels.stats.multicomp import pairwise_tukeyhsd\n", + "import statsmodels.api as sm\n", + "import seaborn as sns\n", + "import warnings\n", + "from matplotlib.collections import PatchCollection\n", + "from matplotlib.colors import Normalize\n", + "from scipy.ndimage import gaussian_filter1d\n", + "from scipy.signal import convolve\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "nwb_paths = [\n", + " \"C:/Users/USER/Desktop/data/sub-619293_ses-1184980079_ogen.nwb\",\n", + " \"C:/Users/USER/Desktop/data/sub-619296_ses-1187930705_ogen.nwb\",\n", + " \"C:/Users/USER/Desktop/data/sub-620333_ses-1188137866_ogen.nwb\",\n", + " \"C:/Users/USER/Desktop/data/sub-620334_ses-1189887297_ogen.nwb\",\n", + " \"C:/Users/USER/Desktop/data/sub-625545_ses-1182865981_ogen.nwb\",\n", + " \"C:/Users/USER/Desktop/data/sub-625554_ses-1181330601_ogen.nwb\",\n", + " \"C:/Users/USER/Desktop/data/sub-625555_ses-1183070926_ogen.nwb\",\n", + " \"C:/Users/USER/Desktop/data/sub-630506_ses-1192952695_ogen.nwb\",\n", + " \"C:/Users/USER/Desktop/data/sub-631510_ses-1196157974_ogen.nwb\",\n", + " \"C:/Users/USER/Desktop/data/sub-631570_ses-1194857009_ogen.nwb\",\n", + " \"C:/Users/USER/Desktop/data/sub-633229_ses-1199247593_ogen.nwb\",\n", + " \"C:/Users/USER/Desktop/data/sub-637484_ses-1208667752_ogen.nwb\"\n", + "]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Fig. 1e : identifying exclusively center-responsive V1 neurons" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# this function defines the receptive fields (RF) of each neuron\n", + "# input R: Nneurons X Ntrials\n", + "# trialorder: trial type of each trial. \n", + "# trial type description: 10000s: classic 0 vs inverse 1, 1000s: which ctrsizes, 10-100s: which RFcenter, 1s: which direction\n", + "def analyzeRFCI(R, trialorder, sponFR):\n", + " if not R.shape[0] == len(sponFR):\n", + " raise ValueError('check sponFR')\n", + "\n", + " Nneurons = R.shape[0]\n", + " Nrfs = 9\n", + " Rrfclassic = np.zeros((Nneurons, Nrfs))\n", + " Rrfinverse = np.zeros((Nneurons, Nrfs))\n", + "\n", + " for rfi in range(Nrfs):\n", + " crftrials = (trialorder // 10000 == 0) & ((trialorder % 1000) // 10 == rfi)\n", + " Rrfclassic[:, rfi] = np.mean(R[:, crftrials], axis=1)\n", + " \n", + " irftrials = (trialorder // 10000 == 1) & ((trialorder % 1000) // 10 == rfi)\n", + " Rrfinverse[:, rfi] = np.mean(R[:, irftrials], axis=1)\n", + " \n", + " RFindclassic = np.argmax(Rrfclassic, axis=1)\n", + " RFindinverse = np.argmax(Rrfinverse, axis=1)\n", + "\n", + " Pkw_rfclassic = np.zeros(Nneurons)\n", + " Pkw_rfinverse = np.zeros(Nneurons)\n", + " sigmc_rfclassic = np.zeros(Nneurons, dtype=bool)\n", + " sigmc_rfinverse = np.zeros(Nneurons, dtype=bool)\n", + "\n", + " for ci in range(Nneurons):\n", + " # Classic\n", + " crftrials = (trialorder // 10000 == 0)\n", + " unique_groups = np.unique(trialorder[crftrials])\n", + " group_labels = trialorder[crftrials]\n", + " data = R[ci, crftrials]\n", + " try:\n", + " p = kruskal(*[data[group_labels == val] for val in unique_groups])[1]\n", + " Pkw_rfclassic[ci] = p\n", + " except ValueError:\n", + " Pkw_rfclassic[ci] = 1\n", + " \n", + " # Perform Tukey HSD if the p-value from Kruskal-Wallis is significant\n", + " if p < 0.05:\n", + " tukey_results = pairwise_tukeyhsd(data, group_labels)\n", + " # Find rows in the Tukey results related to the max firing rate index\n", + " for comparison in tukey_results.summary().data[1:]: # Skip the header row\n", + " if RFindclassic[ci] + 1 in comparison[:2]: # +1 since Python uses 0-indexing\n", + " sigmc_rfclassic[ci] = comparison[4] < 0.05\n", + " break\n", + "\n", + " # Inverse\n", + " irftrials = (trialorder // 10000 == 1)\n", + " unique_groups = np.unique(trialorder[irftrials])\n", + " group_labels = trialorder[irftrials]\n", + " data = R[ci, irftrials]\n", + " try:\n", + " p = kruskal(*[data[group_labels == val] for val in unique_groups])[1]\n", + " Pkw_rfinverse[ci] = p\n", + " except ValueError:\n", + " Pkw_rfinverse[ci] = 1\n", + " # Perform Tukey HSD if the p-value from Kruskal-Wallis is significant\n", + " if p < 0.05:\n", + " tukey_results = pairwise_tukeyhsd(data, group_labels)\n", + " # Find rows in the Tukey results related to the max firing rate index\n", + " for comparison in tukey_results.summary().data[1:]:\n", + " if RFindinverse[ci] + 1 in comparison[:2]: # +1 since Python uses 0-indexing\n", + " sigmc_rfinverse[ci] = comparison[4] < 0.05\n", + " break\n", + "\n", + " pRrfclassic = np.full((Nneurons, Nrfs), np.nan)\n", + " for rfi in range(Nrfs):\n", + " crftrials = (trialorder // 10000 == 0) & ((trialorder % 1000) // 10 == rfi)\n", + " if np.sum(crftrials) == 0:\n", + " continue\n", + " for ci in range(Nneurons):\n", + " try:\n", + " pRrfclassic[ci, rfi] = wilcoxon(R[ci, crftrials] - sponFR[ci]).pvalue\n", + " except ValueError:\n", + " pass\n", + "\n", + " pRrfinverse = np.full((Nneurons, Nrfs), np.nan)\n", + " for rfi in range(Nrfs):\n", + " irftrials = (trialorder // 10000 == 1) & ((trialorder % 1000) // 10 == rfi)\n", + " if np.sum(irftrials) == 0:\n", + " continue\n", + " for ci in range(Nneurons):\n", + " try:\n", + " pRrfinverse[ci, rfi] = wilcoxon(R[ci, irftrials] - sponFR[ci]).pvalue\n", + " except ValueError:\n", + " pass\n", + "\n", + " pRFclassic = pRrfclassic[np.arange(Nneurons), RFindclassic]\n", + " pRFinverse = pRrfinverse[np.arange(Nneurons), RFindinverse]\n", + "\n", + " tempsorted = np.sort(pRrfclassic, axis=1)\n", + " RFsigexclclassic = (pRFclassic * Nrfs < 0.05) & (pRFclassic == tempsorted[:, 0]) & (np.sum(tempsorted * np.arange(Nrfs, 0, -1) < 0.05, axis=1) == 1)\n", + "\n", + " tempsorted = np.sort(pRrfinverse, axis=1)\n", + " RFsigexclinverse = (pRFinverse * Nrfs < 0.05) & (pRFinverse == tempsorted[:, 0]) & (np.sum(tempsorted * np.arange(Nrfs, 0, -1) < 0.05, axis=1) == 1)\n", + "\n", + " RFexclsigclassic = (pRFclassic < 0.05) & (np.sum(pRrfclassic < 0.05, axis=1) == 1)\n", + " RFexclsiginverse = (pRFinverse < 0.05) & (np.sum(pRrfinverse < 0.05, axis=1) == 1)\n", + "\n", + " RFCI = {\n", + " 'Rrfclassic': Rrfclassic,\n", + " 'Rrfinverse': Rrfinverse,\n", + " 'RFindclassic': RFindclassic,\n", + " 'RFindinverse': RFindinverse,\n", + " 'Pkw_rfclassic': Pkw_rfclassic,\n", + " 'Pkw_rfinverse': Pkw_rfinverse,\n", + " 'sigmc_rfclassic': sigmc_rfclassic,\n", + " 'sigmc_rfinverse': sigmc_rfinverse,\n", + " 'pRrfclassic': pRrfclassic,\n", + " 'pRrfinverse': pRrfinverse,\n", + " 'pRFclassic': pRFclassic,\n", + " 'pRFinverse': pRFinverse,\n", + " 'RFsigexclclassic': RFsigexclclassic,\n", + " 'RFsigexclinverse': RFsigexclinverse,\n", + " 'RFexclsigclassic': RFexclsigclassic,\n", + " 'RFexclsiginverse': RFexclsiginverse\n", + " }\n", + "\n", + " return RFCI\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\USER\\AppData\\Local\\Temp\\ipykernel_6344\\2814458195.py:69: UserWarning: last trial was blank\n", + " warnings.warn('last trial was blank')\n", + "C:\\Users\\USER\\AppData\\Local\\Temp\\ipykernel_6344\\2814458195.py:100: UserWarning: check numtrials\n", + " warnings.warn('check numtrials')\n", + "C:\\Users\\USER\\anaconda3\\lib\\site-packages\\scipy\\stats\\_morestats.py:4088: UserWarning: Exact p-value calculation does not work if there are zeros. Switching to normal approximation.\n", + " warnings.warn(\"Exact p-value calculation does not work if there are \"\n", + "C:\\Users\\USER\\anaconda3\\lib\\site-packages\\scipy\\stats\\_morestats.py:4102: UserWarning: Sample size too small for normal approximation.\n", + " warnings.warn(\"Sample size too small for normal approximation.\")\n", + "C:\\Users\\USER\\AppData\\Local\\Temp\\ipykernel_6344\\2814458195.py:62: UserWarning: first trial was blank\n", + " warnings.warn('first trial was blank')\n", + "C:\\Users\\USER\\anaconda3\\lib\\site-packages\\statsmodels\\sandbox\\stats\\multicomp.py:1300: RuntimeWarning: invalid value encountered in divide\n", + " st_range = np.abs(meandiffs) / std_pairs #studentized range statistic\n" + ] + } + ], + "source": [ + "# iterate through sessions and calculate receptive fields for V1 units\n", + "\n", + "RFCI = {i: [] for i in range(len(nwb_paths))}\n", + "sponFRall = {i: [] for i in range(len(nwb_paths))}\n", + "psth_session = {i:[] for i in range(len(nwb_paths))}\n", + "tempR = {i:[] for i in range(len(nwb_paths))}\n", + "vis_dict = {i: {}for i in range(len(nwb_paths))}\n", + "\n", + "for path_idx, path in enumerate(nwb_paths):\n", + " io = NWBHDF5IO(path, mode=\"r\", load_namespaces=True)\n", + " nwb = io.read()\n", + " units = nwb.units\n", + " \n", + " units_qc = []\n", + " unit_isi_violations = units['isi_violations'][:]\n", + " unit_amplitude_cutoff = units['amplitude_cutoff'][:]\n", + " unit_presence_ratio = units['presence_ratio'][:]\n", + "\n", + " # quality control criteria for unit filtering\n", + " units_qc = np.where((unit_isi_violations < 0.5) & (unit_amplitude_cutoff < 0.5) & (unit_presence_ratio > 0.9))[0]\n", + "\n", + " V1electrodeindex = np.where(np.array([s.find('VISp') != -1 and s.find('VISpm') == -1 for s in nwb.electrodes['location'][:]]))[0]\n", + " V1electrode_ids = [nwb.electrodes['id'][idx] for idx in V1electrodeindex]\n", + " electrodes_key = 1000 * nwb.electrodes['probe_id'][:] + nwb.electrodes['local_index']\n", + " V1common_values = np.intersect1d(V1electrode_ids, electrodes_key)\n", + " V1units = np.where(np.isin(units['peak_channel_id'], V1common_values))[0]\n", + " V1units_qc = list(set(V1units) & set(units_qc)) #quality controlled units' indices\n", + "\n", + " max_spike_times = [max(units[\"spike_times\"][unit_idx]) for unit_idx in V1units_qc]\n", + " Tlen = int(np.ceil(max(max_spike_times))) #time lenth for spike train matrix\n", + " spike_times = units[\"spike_times\"][V1units_qc[0:len(V1units_qc)]]\n", + "\n", + " Tres = 0.001\n", + " spiketrain = np.zeros((len(V1units_qc), Tlen*1000), dtype = int)\n", + " for unit_idx in range(len(V1units_qc)):\n", + " unit_spike_times = np.floor(1000 * spike_times[unit_idx]).astype(int)\n", + " #unit_spike_times = unit_spike_times[unit_spike_times < Tlen] # Limit to Tlen\n", + " spiketrain[unit_idx, unit_spike_times] = 1\n", + "\n", + " # vis extracts all releavant information about visual presentations\n", + " vis = {}\n", + " visblocks = list(nwb.intervals.keys()) # Adjust the path according to your NWB file structure\n", + "\n", + " for b in visblocks:\n", + " vis[b] = {}\n", + " vis[b]['start_time'] = nwb.intervals[b]['start_time'][:] # Adjust indexing and loading method\n", + " vis[b]['stop_time'] = nwb.intervals[b]['stop_time'][:] # Adjust indexing and loading method\n", + "\n", + " \n", + " viskeys = list(nwb.intervals[b].colnames)\n", + " for k in viskeys:\n", + " vis[b][k] = nwb.intervals[b][k][:] # Adjust indexing and loading method\n", + " \n", + " \n", + " if 'frame' in vis[b]:\n", + " frame_firsttrial = next((idx for idx, val in enumerate(vis[b]['frame']) if val != 0), None)\n", + " if frame_firsttrial is None:\n", + " continue # Skip if 'frame' is empty or all zeros\n", + "\n", + " # Adjust frame_firsttrial to the nearest multiple of 10\n", + " if frame_firsttrial % 10 != 0:\n", + " warnings.warn('first trial was blank')\n", + " frame_firsttrial = 10 * (frame_firsttrial // 10)\n", + "\n", + " frame_lasttrial = len(vis[b]['frame']) - next((idx for idx, val in enumerate(reversed(vis[b]['frame'])) if val != 0), None) - 1\n", + "\n", + " # Adjust frame_lasttrial to the nearest multiple of 10 + 9\n", + " if frame_lasttrial % 10 != 9:\n", + " warnings.warn('last trial was blank')\n", + " frame_lasttrial = 10 * (frame_lasttrial // 10) + 9\n", + "\n", + " trialframeinds = list(range(frame_firsttrial, frame_lasttrial + 1, 2))\n", + " vis[b]['trialframeinds'] = trialframeinds\n", + " vis[b]['trialstart'] = [vis[b]['start_time'][i] for i in trialframeinds]\n", + " vis[b]['trialend'] = [vis[b]['stop_time'][i] for i in trialframeinds]\n", + " vis[b]['numtrials'] = len(trialframeinds)\n", + " vis[b]['trialorder'] = [vis[b]['frame'][i] for i in trialframeinds]\n", + " \n", + " if 'cfg1' in b:\n", + " vis[b]['trialtypedescription'] = ['Blank', 'X', 'TC1', 'IC1', 'LC1', 'TC2', 'LC2',\n", + " 'IC2', 'IRE1', 'IRE2', 'TRE1', 'TRE2', 'XRE1',\n", + " 'XRE2','InBR', 'InBL', 'InTL', 'InTR', 'OutBR',\n", + " 'OutBL', 'OutTL', 'OutTL']\n", + " elif 'cfg0' in b:\n", + " vis[b]['trialtypedescription'] = ['Blank', 'X', 'TC1', 'IC1', 'LC1', 'TC2', 'LC2',\n", + " 'IC2', 'IRE1', 'IRE2', 'TRE1', 'TRE2', 'XRE1', 'XRE2',\n", + " 'InR', 'InB', 'InL', 'InT', 'OutR', 'OutB', 'OutL', 'OutT']\n", + " else:\n", + " warnings.warn('unrecognized configuration')\n", + " \n", + " vis[b]['ICtrialtypes'] = [0, 101, 105,106,107,109,110,111, 506, 511, 1105, 1109, 1201,\n", + " 1299, 1301, 1302, 1303, 1304, 1305, 1306, 1307, 1308]\n", + "\n", + " if 'ICwcfg1' in vis[b]:\n", + " expectNtrials = 5300 #12*400+10*50\n", + " else:\n", + " expectNtrials = 22*30\n", + " \n", + " if vis[b]['numtrials'] == expectNtrials:\n", + " warnings.warn('check numtrials')\n", + " \n", + " # RFCIblocks\n", + " # (+right, +up)\n", + " # '10000s: which type(classic 0 vs inverse 1), 1000s which ctrsizes, 10~100s which RFcenter,1s: which direction'\n", + "\n", + " if 'y_position' in vis[b].keys():\n", + " vis[b]['trialstart'] = vis[b]['start_time']\n", + " vis[b]['trialend'] = vis[b]['stop_time']\n", + "\n", + " yx_position = np.column_stack((vis[b]['y_position'], vis[b]['x_position']))\n", + " vis[b]['sizepix'] = 203.3786\n", + " vis[b]['MaskDiaVisDeg'] = 16\n", + " # Defining RFcentersrel\n", + " vis[b]['RFcentersrel'] = np.array([\n", + " [-1, 0],\n", + " [-1/np.sqrt(2), 1/np.sqrt(2)],\n", + " [0, 1],\n", + " [1/np.sqrt(2), 1/np.sqrt(2)],\n", + " [1, 0],\n", + " [1/np.sqrt(2), -1/np.sqrt(2)],\n", + " [0, -1],\n", + " [-1/np.sqrt(2), -1/np.sqrt(2)]\n", + " ])\n", + " vis[b]['RFcenters'] = vis[b]['sizepix'] * vis[b]['RFcentersrel']\n", + " vis[b]['RFcentersVisDeg'] = vis[b]['MaskDiaVisDeg'] * vis[b]['RFcentersrel']\n", + " \n", + " \n", + " \n", + " unique_yx_position = np.unique(yx_position, axis=0)\n", + "\n", + "\n", + " all_rfcenters_in_unique_yx = all(np.any(np.all(rfcenter == unique_yx_position, axis=1)) for rfcenter in vis[b]['RFcenters'])\n", + "\n", + " if not all_rfcenters_in_unique_yx:\n", + " raise ValueError('check RFcenters')\n", + " \n", + " vis[b]['directions'] = np.unique(vis[b]['orientation'])\n", + " vis[b]['MaskList'] = np.unique(vis[b]['Mask'])\n", + " \n", + " \n", + " vis[b]['numtrials'] = len(vis[b]['orientation'])\n", + " vis[b]['trialorder'] = np.zeros((vis[b]['numtrials']))\n", + " \n", + " for typi, direction in enumerate(vis[b]['directions']):\n", + " trialsoi = vis[b]['orientation'] == direction\n", + " vis[b]['trialorder'][trialsoi] += typi + 1\n", + "\n", + " for typi in range(len(vis[b]['RFcenters'])):\n", + " trialsoi = np.all(yx_position == vis[b]['RFcenters'][typi, :], axis=1)\n", + " vis[b]['trialorder'][trialsoi] += 10 * (typi + 1)\n", + "\n", + " for typi, mask in enumerate(vis[b]['MaskList']):\n", + " trialsoi = vis[b]['Mask'] == mask\n", + " maskno = int(mask.split('\\\\')[-1].split('.tif')[0])\n", + " vis[b]['trialorder'][trialsoi] += maskno \n", + " \n", + " vis[b]['trialtypedescription'] = ['10000s: classic 0 vs inverse 1,\\\n", + " 1000s: which ctrsizes, 10-100s: which RFcenter, 1s: which direction']\n", + " \n", + " \n", + " \n", + "\n", + " if 'sizeCI' in b:\n", + " vis[b]['trialstart'] = vis[b]['start_time']\n", + " vis[b]['trialend'] = vis[b]['stop_time']\n", + "\n", + " vis[b]['directions'] = pd.unique(vis[b]['orientation'])\n", + " vis[b]['MaskList'] = pd.unique(vis[b]['Mask'])\n", + " \n", + "\n", + " vis[b]['numtrials'] = len(vis[b]['orientation'])\n", + " vis[b]['trialorder'] = np.zeros(vis[b]['numtrials'])\n", + "\n", + " for typi, direction in enumerate(vis[b]['directions']):\n", + " trialsoi = vis[b]['orientation'] == direction\n", + " vis[b]['trialorder'][trialsoi] += typi + 1\n", + "\n", + " for typi, mask in enumerate(vis[b]['MaskList']):\n", + " trialsoi = [m == mask for m in vis[b]['Mask']]\n", + " tempss = mask.split('\\\\')[-1].split('.tif')[0]\n", + " maskno = int(tempss)\n", + " vis[b]['trialorder'][trialsoi] += maskno\n", + " \n", + " vis[b]['MaskDiaVisDeg'] = [0, 4, 8, 16, 32, 64]\n", + " vis[b]['trialtypedescription'] = ['10000s: classic 0 vs inverse 1,\\\n", + " 1000s: which ctrsizes, 10-100s: which RFcenter, 1s: which direction']\n", + "\n", + " \n", + " \n", + " \n", + " durations = vis['spontaneous_presentations']['stop_time'] - vis['spontaneous_presentations']['start_time']\n", + " mv = np.max(durations)\n", + " mi = np.argmax(durations)\n", + " \n", + "\n", + " # Calculate start and end indices\n", + " sponTstartind = np.floor(vis['spontaneous_presentations']['start_time'][mi] / Tres).astype(int) + 1\n", + " sponTendind = np.floor(vis['spontaneous_presentations']['stop_time'][mi] / Tres).astype(int)\n", + "\n", + " # Compute mean firing rates\n", + " sponFRall[path_idx] = np.mean(spiketrain[:, sponTstartind:sponTendind], axis=1) / Tres\n", + " meanFRall = np.mean(spiketrain, axis=1) / Tres\n", + " \n", + " psth = {}\n", + " psthtli = np.arange(-500, 1000)\n", + " for b in visblocks:\n", + " if 'spontaneous' in b or 'invalid_times' in b:\n", + " continue\n", + " \n", + " \n", + "\n", + " trialstart_array = np.array(vis[b]['trialstart'])\n", + " psthtrialinds = np.floor(trialstart_array / Tres).astype(int) + 1\n", + " num_trials = len(trialstart_array)\n", + " num_units = len(V1units_qc)\n", + " psth[b] = np.zeros((num_units, num_trials, len(psthtli)), dtype=int)\n", + "\n", + " for ii in range(len(V1units_qc)):\n", + " for trial, trial_start in enumerate(psthtrialinds):\n", + " trial_start = int(trial_start)\n", + " indices = trial_start + psthtli\n", + " psth[b][ii, trial, :] = spiketrain[ii, indices]\n", + " \n", + " psth_session[path_idx] = psth\n", + " vis_dict[path_idx] = vis\n", + " \n", + " tloi = (psthtli > 0) & (psthtli <= 1000)\n", + " tempR[path_idx] = 1000 * np.mean(psth['RFCI_presentations'][:, ::4, tloi], axis=2).squeeze()\n", + " temptrialorder = vis['RFCI_presentations']['trialorder'][::4]\n", + "\n", + " # Assuming the function analyzeRFCI is already defined as per the previous translation\n", + " RFCI[path_idx] = analyzeRFCI(tempR[path_idx], temptrialorder, sponFRall[path_idx])\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "num_signeurons = 0\n", + "sig_neurons = {i: [] for i in range(len(nwb_paths))}\n", + "for path_idx in range(len(nwb_paths)):\n", + " sig_neurons[path_idx] = np.where(np.logical_and(RFCI[path_idx]['RFsigexclclassic'], RFCI[path_idx]['RFindclassic'] == 0))[0]\n", + " num_signeurons += len(sig_neurons[path_idx])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "29" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "num_signeurons" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "RFcenters = np.vstack(([0, 0], vis_dict[0]['RFCI_presentations']['RFcenters']))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0. , 0. ],\n", + " [-203.3786 , 0. ],\n", + " [-143.81038721, 143.81038721],\n", + " [ 0. , 203.3786 ],\n", + " [ 143.81038721, 143.81038721],\n", + " [ 203.3786 , 0. ],\n", + " [ 143.81038721, -143.81038721],\n", + " [ 0. , -203.3786 ],\n", + " [-143.81038721, -143.81038721]])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "RFcenters" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# select trial order index what we want\n", + "position_all = {i:[]for i in range(len(nwb_paths))}\n", + "for path_idx in range(len(nwb_paths)):\n", + " nrf = 9\n", + "\n", + " trialorder = vis_dict[path_idx]['RFCI_presentations']['trialorder']\n", + " position= {i:[] for i in range(nrf)}\n", + " \n", + " for i in range(nrf):\n", + " position[i] = np.where(np.logical_and(vis_dict[path_idx]['RFCI_presentations']['trialorder']//10%10 == i, vis_dict[path_idx]['RFCI_presentations']['trialorder']//10000 == 0))[0][::4]\n", + " position_all[path_idx] = position\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "mean_psth_all = {i:[] for i in range(nrf)}\n", + "for path_idx in range(len(nwb_paths)):\n", + " if not len(sig_neurons[path_idx]) == 0:\n", + " sig_psth = psth_session[path_idx]['RFCI_presentations'][sig_neurons[path_idx],:,:]\n", + " for i in range(nrf):\n", + " mean_psth = (sig_psth[:, position_all[path_idx][i],500:])/Tres - sponFRall[path_idx][sig_neurons[path_idx]][:, np.newaxis, np.newaxis]\n", + " mean_psth_all[i].append(mean_psth)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "each_mean_psth = {i:[] for i in range(nrf)}\n", + "for i in range(nrf):\n", + " each_mean_psth[i] = np.mean(np.concatenate(mean_psth_all[i], axis = 0), axis = (1, 2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### plot the receptive field of each exclusively center-responsive V1 neuron" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cols = 6\n", + "rows = 5\n", + "\n", + "fig, axes = plt.subplots(rows, cols, figsize=(20, 15)) \n", + "axes = axes.flatten() \n", + "\n", + "for num in range(num_signeurons):\n", + " firing_rate_allneurons = []\n", + " for i in range(nrf):\n", + " firing_rate_allneurons.append(each_mean_psth[i][num])\n", + "\n", + " radius = max(np.unique([y for y, x in RFcenters])) * 2 / 4\n", + "\n", + " ax = axes[num]\n", + "\n", + " # Create a list to hold the circle patches\n", + " circles = []\n", + "\n", + " # Loop through each position and create a circle patch with the mean firing rate color\n", + " for idx, (rate, (y, x)) in enumerate(zip(firing_rate_allneurons, RFcenters)):\n", + " circle = patches.Circle((x, y), radius)\n", + " circles.append(circle)\n", + " ax.text(x, y, str(range(nrf)[idx]), color='black', ha='center', va='center', fontsize=12)\n", + "\n", + " # Create a patch collection with the circles\n", + " p = PatchCollection(circles, cmap='bwr', alpha=0.8)\n", + "\n", + " # Set the array for the colormap with normalized firing rates\n", + " p.set_array(firing_rate_allneurons)\n", + " p.set_clim([0, 8])\n", + " p.set_norm(Normalize(vmin=min(firing_rate_allneurons), vmax=max(firing_rate_allneurons)))\n", + "\n", + " # Add the patch collection to the axis\n", + " ax.add_collection(p)\n", + "\n", + " # Format the plot\n", + " ax.set_aspect('equal')\n", + " ax.set_xlim(-320, 320)\n", + " ax.set_ylim(-320, 320)\n", + " ax.axis('off')\n", + "\n", + " \n", + " fig.colorbar(p, ax=ax, fraction=0.046, pad=0.04)\n", + "\n", + "\n", + "for ax in axes[num_signeurons:]:\n", + " ax.axis('off')\n", + "\n", + "plt.tight_layout()\n", + "plt.subplots_adjust(wspace=0.4, hspace=0.4)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "firing_rate_position = []\n", + "for i in range(nrf):\n", + " firing_rate = np.mean(np.concatenate(mean_psth_all[i], axis = 0))\n", + " firing_rate_position.append(firing_rate)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## plot the average of exclusively center-responsive V1 neurons" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Initialize the figure and axis\n", + "fig, ax = plt.subplots()\n", + "\n", + "# Create a list to hold the circle patches\n", + "circles = []\n", + "\n", + "# Loop through each position and create a circle patch with the mean firing rate color\n", + "for idx, (rate, (y, x)) in enumerate(zip(firing_rate_position, RFcenters)):\n", + " circle = patches.Circle((x, y), radius)\n", + " circles.append(circle)\n", + " ax.text(x, y, str(range(nrf)[idx]), color='black', ha='center', va='center', fontsize=12)\n", + "\n", + "# Create a patch collection with the circles\n", + "p = PatchCollection(circles, cmap='bwr', alpha=0.8)\n", + "\n", + "# Set the array for the colormap with normalized firing rates\n", + "p.set_array(firing_rate_position)\n", + "p.set_clim([0, 8])\n", + "p.set_norm(Normalize(vmin=0, vmax=8))\n", + "\n", + "# Add the patch collection to the axis\n", + "ax.add_collection(p)\n", + "\n", + "# Format the plot\n", + "ax.set_aspect('equal')\n", + "ax.set_xlim(-320, 320)\n", + "ax.set_ylim(-320, 320)\n", + "plt.axis('off')\n", + "\n", + "# Create a colorbar\n", + "cbar = plt.colorbar(p, ax=ax)\n", + "cbar.set_label('ΔFiring Rate (Hz)', rotation=270, labelpad=15)\n", + "cbar.set_ticks([0, 2, 4, 6, 8])\n", + "# Show the plot\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Figure. 1f : stacked peri-stimulus time histograms (PSTHs) depicting evoked responses to $I_{C}$ and $I_{RE}$ images for exclusively center-responsive V1 neurons\n", + "\n", + "note, we are subtracting spontaneous period activity from each neuron to assess the magnitude of visual evoked activity (i.e., change from baseline)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "ICtrials = [7, 3] #trial order is 45, 135 dgree in ICwcfg1_presentations, 0, 90 degree in ICwcfg0_presentations\n", + "REtrials = [9, 8]" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "IC_aggregate_list1 = []\n", + "RE_aggregate_list1 = []\n", + "for path_idx in range(len(nwb_paths)):\n", + " sig = sig_neurons[path_idx]\n", + " if not len(sig) == 0: \n", + " trial_order = vis_dict[path_idx]['ICwcfg1_presentations']['trialorder']\n", + " \n", + " indices_by_element = {}\n", + " for item in ICtrials:\n", + " indices = np.where(np.array(trial_order) == item)[0]\n", + " indices_by_element[item] = indices.tolist()\n", + "\n", + " for item in REtrials:\n", + " indices = np.where(np.array(trial_order) == item)[0]\n", + " indices_by_element[item] = indices.tolist()\n", + "\n", + "\n", + " sig_psth1 = psth_session[path_idx]['ICwcfg1_presentations'][sig,:,:] / Tres - sponFRall[path_idx][sig][:, np.newaxis, np.newaxis]\n", + "\n", + "\n", + " ICpsth = np.concatenate([sig_psth1[:, indices_by_element[idx], :] for idx in ICtrials], axis = 1) # Concatenate along the trial axis\n", + " REpsth = np.concatenate([sig_psth1[:, indices_by_element[idx], :] for idx in REtrials], axis = 1) # Concatenate along the trial axis\n", + "\n", + " IC_aggregate_list1.append(ICpsth)\n", + " RE_aggregate_list1.append(REpsth)\n", + "\n", + "# After all files are processed, concatenate the list of arrays into a single array\n", + "if IC_aggregate_list1:\n", + " IC_1 = np.concatenate(IC_aggregate_list1, axis=0) # Concatenate along the neuron axis\n", + "if RE_aggregate_list1:\n", + " RE_1 = np.concatenate(RE_aggregate_list1, axis=0)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "IC_aggregate_list0 = []\n", + "RE_aggregate_list0 = []\n", + "for path_idx in range(len(nwb_paths)):\n", + " sig = sig_neurons[path_idx]\n", + " if not len(sig) == 0: \n", + " trial_order = vis_dict[path_idx]['ICwcfg0_presentations']['trialorder']\n", + "\n", + " indices_by_element = {}\n", + " for item in ICtrials:\n", + " indices = np.where(np.array(trial_order) == item)[0]\n", + " indices_by_element[item] = indices.tolist()\n", + "\n", + " for item in REtrials:\n", + " indices = np.where(np.array(trial_order) == item)[0]\n", + " indices_by_element[item] = indices.tolist()\n", + "\n", + " sig_psth0 = psth_session[path_idx]['ICwcfg0_presentations'][sig,:,:] / Tres - sponFRall[path_idx][sig][:, np.newaxis, np.newaxis]\n", + "\n", + "\n", + " ICpsth = np.concatenate([sig_psth0[:, indices_by_element[idx], :] for idx in ICtrials], axis = 1) # Concatenate along the trial axis\n", + " REpsth = np.concatenate([sig_psth0[:, indices_by_element[idx], :] for idx in REtrials], axis = 1) # Concatenate along the trial axis\n", + "\n", + " IC_aggregate_list0.append(ICpsth)\n", + " RE_aggregate_list0.append(REpsth)\n", + "\n", + "# After all files are processed, concatenate the list of arrays into a single array\n", + "if IC_aggregate_list0:\n", + " IC_0 = np.concatenate(IC_aggregate_list0, axis=0) # Concatenate along the neuron axis\n", + "if RE_aggregate_list0:\n", + " RE_0 = np.concatenate(RE_aggregate_list0, axis=0)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "IC_aggregate = np.concatenate([IC_0, IC_1], axis = 1)\n", + "RE_aggregate = np.concatenate([RE_0, RE_1], axis = 1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "kernel = np.full(25,1)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "IC_convol = np.apply_along_axis(lambda x: np.convolve(x, kernel, 'same'), axis=2, arr=IC_aggregate) / (np.sum(kernel))\n", + "IC_mean = np.mean(IC_convol, axis = (0,1))\n", + "\n", + "SEM_IC = (np.std(np.mean(IC_convol, axis = 1), axis = 0)/np.sqrt(IC_convol.shape[0]))\n", + "\n", + "plt.subplot(1,2,1)\n", + "plt.plot(psthtli, IC_mean, color = 'g')\n", + "plt.fill_between(psthtli, (IC_mean-SEM_IC), (IC_mean + SEM_IC), color = 'g', alpha = 0.2)\n", + "plt.xlabel('Time(ms)')\n", + "plt.ylabel('Rate(Hz)')\n", + "plt.xlim(0, 400)\n", + "plt.ylim(-1, 20)\n", + "plt.xticks(np.arange(0, 400, 200))\n", + "plt.title('IC trials', color = 'g')\n", + "\n", + "\n", + "RE_convol = np.apply_along_axis(lambda x: np.convolve(x, kernel, 'same'), axis=2, arr=RE_aggregate) / (np.sum(kernel))\n", + "RE_mean = np.mean(RE_convol, axis =(0,1))\n", + "\n", + "SEM_RE = (np.std(np.mean(RE_convol, axis = 1), axis = 0)/np.sqrt(RE_convol.shape[0]))\n", + "plt.subplot(1,2,2)\n", + "plt.plot(psthtli, RE_mean, color = 'b')\n", + "plt.fill_between(psthtli, (RE_mean-SEM_RE), (RE_mean + SEM_RE), color = 'b', alpha = 0.2)\n", + "plt.xlim(0, 400)\n", + "plt.ylim(-1, 20)\n", + "plt.xticks(np.arange(0, 400, 200))\n", + "\n", + "plt.title('RE trials', color = 'b')\n", + "plt.xlabel('Time(ms)')\n", + "\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sigma = 1\n", + "IC_convol = gaussian_filter1d(IC_aggregate, sigma=sigma, axis=2)\n", + "RE_convol = gaussian_filter1d(RE_aggregate, sigma=sigma, axis=2)\n", + "\n", + "stim_time = (psthtli > 0) & (psthtli <= 400)\n", + "sorted_indices = np.argsort(np.mean(IC_convol[:,:,stim_time], axis=(1,2)))[::-1]\n", + "\n", + "IC_heat = np.mean(IC_convol[:,:,stim_time], axis=1)\n", + "RE_heat = np.mean(RE_convol[:,:,stim_time], axis=1)\n", + "\n", + "sorted_IC_heat = IC_heat[sorted_indices, :]\n", + "sorted_RE_heat = RE_heat[sorted_indices, :] #in same order with IC heat\n", + "\n", + "\n", + "fig, axes = plt.subplots(ncols=2, figsize=(10, 5))\n", + "\n", + "sns.heatmap(sorted_IC_heat, ax=axes[0], cmap='bwr', cbar_kws={'label': 'ΔRate (Hz)'}, vmin=-50, vmax=50)\n", + "axes[0].set_title('PSTH per Neuron')\n", + "axes[0].set_xlabel('Time (s)')\n", + "axes[0].set_ylabel('Neurons')\n", + "axes[0].set_ylim(sorted_IC_heat.shape[0], 0)\n", + "axes[0].set_yticks([0, sorted_IC_heat.shape[0]])\n", + "axes[0].set_yticklabels(['0', str(sorted_IC_heat.shape[0])])\n", + "axes[0].set_xticks(np.linspace(0, 400, 3))\n", + "axes[0].set_xticklabels(['0', '0.2', '0.4'])\n", + "\n", + "\n", + "sns.heatmap(sorted_RE_heat, ax=axes[1], cmap='bwr', cbar_kws={'label': 'ΔRate (Hz)'}, vmin=-50, vmax=50)\n", + "axes[1].set_title('PSTH per Neuron')\n", + "axes[1].set_xlabel('Time (s)')\n", + "axes[1].set_ylabel('Neurons')\n", + "axes[1].set_ylim(sorted_RE_heat.shape[0], 0)\n", + "axes[1].set_yticks([0, sorted_RE_heat.shape[0]])\n", + "axes[1].set_yticklabels(['0', str(sorted_RE_heat.shape[0])])\n", + "axes[1].set_xticks(np.linspace(0, 400, 3))\n", + "axes[1].set_xticklabels(['0', '0.2', '0.4'])\n", + "\n", + "plt.tight_layout() \n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Fig. 1g : for exclusively center-responsive V1 neurons that are also responsive to at least one of the four $I_{C}$ images, compare the preferred orientation for $I_{C}$ vs $I_{RE}$ images" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "# Define neurons that significantly respond to IC images.\n", + "sig_IC = [3,7]\n", + "blank_aggregate1 = []\n", + "blank_aggregate0 = []\n", + "IC_aggregate_list1 = []\n", + "IC_aggregate_list0 = []\n", + "for path_idx in range(len(nwb_paths)):\n", + " sig = sig_neurons[path_idx]\n", + " if not len(sig) == 0: \n", + " trial_order = vis_dict[path_idx]['ICwcfg1_presentations']['trialorder']\n", + " \n", + " indices_by_element = {}\n", + " for item in sig_IC:\n", + " indices = np.where(np.array(trial_order) == item)[0]\n", + " indices_by_element[item] = indices.tolist()\n", + " indices_by_element[0] = np.where(np.array(trial_order) == 0) #index of blank\n", + " \n", + "\n", + " sig_psth1 = psth_session[path_idx]['ICwcfg1_presentations'][sig,:,:] / Tres\n", + " \n", + " ICpsth = np.concatenate([sig_psth1[:, indices_by_element[idx], :] for idx in sig_IC], axis = 1) # Concatenate along the trial axis\n", + " blank_psth = np.concatenate([sig_psth1[:, indices_by_element[0][0], :]], axis=1)\n", + "\n", + " \n", + " IC_aggregate_list1.append(ICpsth)\n", + " blank_aggregate1.append(blank_psth)\n", + " \n", + " \n", + "for path_idx in range(len(nwb_paths)):\n", + " sig = sig_neurons[path_idx]\n", + " if not len(sig) == 0: \n", + " trial_order = vis_dict[path_idx]['ICwcfg0_presentations']['trialorder']\n", + " \n", + " indices_by_element = {}\n", + " for item in sig_IC:\n", + " indices = np.where(np.array(trial_order) == item)[0]\n", + " indices_by_element[item] = indices.tolist()\n", + " indices_by_element[0] = np.where(np.array(trial_order) == 0)\n", + " \n", + "\n", + "\n", + " sig_psth1 = psth_session[path_idx]['ICwcfg0_presentations'][sig,:,:] / Tres\n", + " \n", + "\n", + " ICpsth = np.concatenate([sig_psth1[:, indices_by_element[idx], :] for idx in sig_IC], axis = 1) # Concatenate along the trial axis\n", + " blank_psth = np.concatenate([sig_psth1[:, indices_by_element[0][0], :]], axis=1)\n", + "\n", + "\n", + " IC_aggregate_list0.append(ICpsth)\n", + " blank_aggregate0.append(blank_psth)\n", + "\n", + "# After all files are processed, concatenate the list of arrays into a single array\n", + "if IC_aggregate_list1:\n", + " sig_IC_1 = np.concatenate(IC_aggregate_list1, axis=0) # Concatenate along the neuron axis\n", + " \n", + "if IC_aggregate_list0:\n", + " sig_IC_0 = np.concatenate(IC_aggregate_list0, axis=0)\n", + " \n", + "if blank_aggregate0:\n", + " sig_blank_0 = np.concatenate(blank_aggregate0, axis=0)\n", + " \n", + "if blank_aggregate1:\n", + " sig_blank_1 = np.concatenate(blank_aggregate1, axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "mean_IC_0 = np.mean(sig_IC_0[:,:, stim_time], axis=2)\n", + "mean_blank_0 = np.mean(sig_blank_0[:,:, stim_time], axis=2)\n", + "\n", + "len_IC1 = int(mean_IC_0.shape[1]/2)\n", + "\n", + "p_values0_IC1 = []\n", + "p_values0_IC2 = []\n", + "for i in range(mean_IC_0.shape[0]):\n", + " #Statistics on 'blank' and 'IC1 trial' in ICwcfg0 presentations\n", + " stat, p = stats.mannwhitneyu(mean_IC_0[i, :len_IC1], mean_blank_0[i, :], alternative='greater')\n", + " p_values0_IC1.append(p)\n", + " \n", + " #Statistics on 'blank' and 'IC2 trial' in ICwcfg0 presentations\n", + " stat, p = stats.mannwhitneyu(mean_IC_0[i, len_IC1:], mean_blank_0[i, :], alternative='greater')\n", + " p_values0_IC2.append(p)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "mean_IC_1 = np.mean(sig_IC_1[:,:, stim_time], axis=2)\n", + "mean_blank_1 = np.mean(sig_blank_1[:,:, stim_time], axis=2)\n", + "\n", + "len_IC1 = int(mean_IC_1.shape[1]/2)\n", + "\n", + "p_values1_IC1 = []\n", + "p_values1_IC2 = []\n", + "\n", + "for i in range(mean_IC_1.shape[0]):\n", + " # Statistics on 'blank' and 'IC1 trial' in ICwcfg1 presentations\n", + " stat, p = stats.mannwhitneyu(mean_IC_1[i, :len_IC1], mean_blank_1[i, :], alternative='greater')\n", + " p_values1_IC1.append(p)\n", + " #Statistics on 'blank' and 'IC2 trial' in ICwcfg1 presentations\n", + " stat, p = stats.mannwhitneyu(mean_IC_1[i, len_IC1:], mean_blank_1[i, :], alternative='greater')\n", + " p_values1_IC2.append(p)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "p_values_list = [p_values0_IC1, p_values0_IC2, p_values1_IC1, p_values1_IC2]\n", + "p_values = np.zeros((num_signeurons, len(p_values_list)))\n", + "for idx, p in enumerate(p_values_list):\n", + " p_values[:, idx] = p\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "IC_sig_ind = np.where((np.sort(p_values, axis = 1) * np.arange(4, 0, -1))[:,0] < 0.05)[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "order of IC_means and RE_means is **0, 45, 90, 135 degree**" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "len_IC0 = int(IC_0.shape[1]/2)\n", + "len_IC1 = int(IC_1.shape[1]/2)\n", + "len_RE0 = int(RE_0.shape[1]/2)\n", + "len_RE1 = int(RE_1.shape[1]/2)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "IC_means = [\n", + " np.mean(IC_0[:, 0:len_IC0, stim_time], axis=(1,2)),\n", + " np.mean(IC_1[:, 0:len_IC1, stim_time], axis=(1,2)),\n", + " np.mean(IC_0[:, len_IC0:len_IC0*2, stim_time], axis=(1,2)),\n", + " np.mean(IC_1[:, len_IC1:len_IC1*2, stim_time], axis=(1,2))\n", + "]\n", + "\n", + "\n", + "IC_combined_means = np.array(IC_means).T\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "RE_means = [\n", + " np.mean(RE_0[:, 0:len_RE0, stim_time], axis=(1,2)),\n", + " np.mean(RE_1[:, 0:len_RE1, stim_time], axis=(1,2)),\n", + " np.mean(RE_0[:, len_RE0:len_RE0*2, stim_time], axis=(1,2)),\n", + " np.mean(RE_1[:, len_RE1:len_RE1*2, stim_time], axis=(1,2))\n", + "]\n", + "\n", + "\n", + "RE_combined_means = np.array(RE_means).T\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "RE_max_idx = np.argmax(RE_combined_means[IC_sig_ind], axis = 1)\n", + "IC_max_idx = np.argmax(IC_combined_means[IC_sig_ind], axis = 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "pref_ori = np.zeros((RE_combined_means.shape[1], IC_combined_means.shape[1]), dtype = int)\n", + "for re_idx, ic_idx in zip(RE_max_idx, IC_max_idx):\n", + " pref_ori[re_idx, ic_idx] += 1" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "orientations = [0, 45, 90, 135]\n", + "\n", + "\n", + "plt.figure(figsize=(5, 4))\n", + "sns.heatmap(pref_ori, fmt=\"d\", cmap='bwr', cbar_kws={'label': '# Neurons'}, vmin=0, vmax=8)\n", + "plt.title('Orientation Preference')\n", + "plt.xlabel('Pref. IC Orientation')\n", + "plt.ylabel('Pref. RE Orientation')\n", + "plt.xticks(np.arange(len(orientations)) + 0.5, labels=orientations)\n", + "plt.yticks(np.arange(len(orientations)) + 0.5, labels=orientations, rotation=0)\n", + "plt.show()" + ] } ], "metadata": { @@ -2910,7 +4120,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.10" + "version": "3.10.9" } }, "nbformat": 4, From 2cc27f3f98ca1ddc48a68264d45d08546392dcc9 Mon Sep 17 00:00:00 2001 From: KimYeerim Date: Fri, 28 Jun 2024 10:38:15 +0900 Subject: [PATCH 2/3] Change session and update graph color bar settings 1. Changed the session used for analysis to `sub-633229_ses-1199247593_ogen.nwb`. 2. Enhanced the clarity of the graph by updating the graph color bars and other elements --- docs/projects/illusion.ipynb | 341 ++++++++++++++++++++++++++--------- 1 file changed, 259 insertions(+), 82 deletions(-) diff --git a/docs/projects/illusion.ipynb b/docs/projects/illusion.ipynb index 2185fa80..38f8b8db 100644 --- a/docs/projects/illusion.ipynb +++ b/docs/projects/illusion.ipynb @@ -23,9 +23,184 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "d:\\Users\\USER\\Documents\\GitHub\\openscope_databook\\docs\\projects\\openscope_databook\\docs\\projects\\openscope_databook\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "fatal: destination path 'openscope_databook' already exists and is not an empty directory.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Obtaining file:///D:/Users/USER/Documents/GitHub/openscope_databook/docs/projects/openscope_databook/docs/projects/openscope_databookNote: you may need to restart the kernel to use updated packages.\n", + "\n", + " Installing build dependencies: started\n", + " Installing build dependencies: finished with status 'done'\n", + " Checking if build backend supports build_editable: started\n", + " Checking if build backend supports build_editable: finished with status 'done'\n", + " Getting requirements to build editable: started\n", + " Getting requirements to build editable: finished with status 'done'\n", + " Preparing editable metadata (pyproject.toml): started\n", + " Preparing editable metadata (pyproject.toml): finished with status 'done'\n", + "Collecting ophys-nway-matching@ git+https://github.com/AllenInstitute/ophys_nway_matching@545504ab55922717ab623f8ede2c521a60aa1458 (from databook_utils==1.0.0)\n", + " Cloning https://github.com/AllenInstitute/ophys_nway_matching (to revision 545504ab55922717ab623f8ede2c521a60aa1458) to c:\\users\\user\\appdata\\local\\temp\\pip-install-psn60bj9\\ophys-nway-matching_8ebf834539734420830fb5809b6d6e9e\n", + " Resolved https://github.com/AllenInstitute/ophys_nway_matching to commit 545504ab55922717ab623f8ede2c521a60aa1458\n", + " Installing build dependencies: started\n", + " Installing build dependencies: finished with status 'done'\n", + " Getting requirements to build wheel: started\n", + " Getting requirements to build wheel: finished with status 'done'\n", + " Preparing metadata (pyproject.toml): started\n", + " Preparing metadata (pyproject.toml): finished with status 'done'\n", + "Collecting ccfwidget==0.5.3 (from databook_utils==1.0.0)\n", + " Using cached ccfwidget-0.5.3-py3-none-any.whl.metadata (614 bytes)\n", + "Collecting cebra (from databook_utils==1.0.0)\n", + " Using cached cebra-0.4.0-py2.py3-none-any.whl.metadata (5.8 kB)\n", + "Collecting dandi==0.55.1 (from databook_utils==1.0.0)\n", + " Using cached dandi-0.55.1-py3-none-any.whl.metadata (7.6 kB)\n", + "Collecting elephant==0.12.0 (from databook_utils==1.0.0)\n", + " Using cached elephant-0.12.0.tar.gz (2.7 MB)\n", + " Installing build dependencies: started\n", + " Installing build dependencies: finished with status 'done'\n", + " Getting requirements to build wheel: started\n", + " Getting requirements to build wheel: finished with status 'done'\n", + " Preparing metadata (pyproject.toml): started\n", + " Preparing metadata (pyproject.toml): finished with status 'done'\n", + "Collecting h5py==3.7 (from databook_utils==1.0.0)\n", + " Using cached h5py-3.7.0.tar.gz (392 kB)\n", + " Installing build dependencies: started\n", + " Installing build dependencies: finished with status 'done'\n", + " Getting requirements to build wheel: started\n", + " Getting requirements to build wheel: finished with status 'done'\n", + " Preparing metadata (pyproject.toml): started\n", + " Preparing metadata (pyproject.toml): finished with status 'done'\n", + "Collecting jupyter==1.0.0 (from databook_utils==1.0.0)\n", + " Using cached jupyter-1.0.0-py2.py3-none-any.whl.metadata (995 bytes)\n", + "Collecting matplotlib==3.6.2 (from databook_utils==1.0.0)\n", + " Using cached matplotlib-3.6.2.tar.gz (35.8 MB)\n", + " Installing build dependencies: started\n", + " Installing build dependencies: finished with status 'done'\n", + " Getting requirements to build wheel: started\n", + " Getting requirements to build wheel: finished with status 'done'\n", + " Installing backend dependencies: started\n", + " Installing backend dependencies: finished with status 'done'\n", + " Preparing metadata (pyproject.toml): started\n", + " Preparing metadata (pyproject.toml): finished with status 'done'\n", + "Collecting mpl-interactions==0.22.0 (from databook_utils==1.0.0)\n", + " Using cached mpl_interactions-0.22.0-py3-none-any.whl.metadata (10 kB)\n", + "Collecting neo==0.12.0 (from databook_utils==1.0.0)\n", + " Using cached neo-0.12.0-py3-none-any.whl.metadata (7.5 kB)\n", + "Requirement already satisfied: numpy in c:\\users\\user\\appdata\\local\\programs\\python\\python312\\lib\\site-packages (from databook_utils==1.0.0) (1.26.4)\n", + "Collecting nwbwidgets==0.10.0 (from databook_utils==1.0.0)\n", + " Using cached nwbwidgets-0.10.0-py3-none-any.whl.metadata (4.3 kB)\n", + "Collecting pandas==1.5.2 (from databook_utils==1.0.0)\n", + " Using cached pandas-1.5.2.tar.gz (5.2 MB)\n", + " Installing build dependencies: started\n", + " Installing build dependencies: finished with status 'done'\n", + " Getting requirements to build wheel: started\n", + " Getting requirements to build wheel: finished with status 'done'\n", + " Preparing metadata (pyproject.toml): started\n", + " Preparing metadata (pyproject.toml): finished with status 'done'\n", + "Collecting Pillow==9.3.0 (from databook_utils==1.0.0)\n", + " Using cached Pillow-9.3.0.tar.gz (50.4 MB)\n", + " Installing build dependencies: started\n", + " Installing build dependencies: finished with status 'done'\n", + " Getting requirements to build wheel: started\n", + " Getting requirements to build wheel: finished with status 'done'\n", + " Preparing metadata (pyproject.toml): started\n", + " Preparing metadata (pyproject.toml): finished with status 'done'\n", + "Collecting pynwb==2.2.0 (from databook_utils==1.0.0)\n", + " Using cached pynwb-2.2.0-py3-none-any.whl.metadata (9.4 kB)\n", + "Collecting quantities==0.14.1 (from databook_utils==1.0.0)\n", + " Using cached quantities-0.14.1-py3-none-any.whl.metadata (8.4 kB)\n", + "Collecting remfile==0.1.10 (from databook_utils==1.0.0)\n", + " Using cached remfile-0.1.10-py3-none-any.whl.metadata (3.6 kB)\n", + "Collecting scikit-image==0.19.3 (from databook_utils==1.0.0)\n", + " Using cached scikit-image-0.19.3.tar.gz (22.2 MB)\n", + " Installing build dependencies: started\n", + " Installing build dependencies: finished with status 'done'\n", + " Getting requirements to build wheel: started\n", + " Getting requirements to build wheel: finished with status 'error'\n", + "d:\\Users\\USER\\Documents\\GitHub\\openscope_databook\\docs\\projects\\openscope_databook\\docs\\projects\\openscope_databook\\docs\\projects\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " Running command git clone --filter=blob:none --quiet https://github.com/AllenInstitute/ophys_nway_matching 'C:\\Users\\USER\\AppData\\Local\\Temp\\pip-install-psn60bj9\\ophys-nway-matching_8ebf834539734420830fb5809b6d6e9e'\n", + " Running command git rev-parse -q --verify 'sha^545504ab55922717ab623f8ede2c521a60aa1458'\n", + " Running command git fetch -q https://github.com/AllenInstitute/ophys_nway_matching 545504ab55922717ab623f8ede2c521a60aa1458\n", + " Running command git checkout -q 545504ab55922717ab623f8ede2c521a60aa1458\n", + " error: subprocess-exited-with-error\n", + " \n", + " × Getting requirements to build wheel did not run successfully.\n", + " │ exit code: 1\n", + " ╰─> [33 lines of output]\n", + " Traceback (most recent call last):\n", + " File \"c:\\Users\\USER\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pip\\_vendor\\pyproject_hooks\\_in_process\\_in_process.py\", line 353, in \n", + " main()\n", + " File \"c:\\Users\\USER\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pip\\_vendor\\pyproject_hooks\\_in_process\\_in_process.py\", line 335, in main\n", + " json_out['return_val'] = hook(**hook_input['kwargs'])\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"c:\\Users\\USER\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pip\\_vendor\\pyproject_hooks\\_in_process\\_in_process.py\", line 112, in get_requires_for_build_wheel\n", + " backend = _build_backend()\n", + " ^^^^^^^^^^^^^^^^\n", + " File \"c:\\Users\\USER\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pip\\_vendor\\pyproject_hooks\\_in_process\\_in_process.py\", line 77, in _build_backend\n", + " obj = import_module(mod_path)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"c:\\Users\\USER\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\importlib\\__init__.py\", line 90, in import_module\n", + " return _bootstrap._gcd_import(name[level:], package, level)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"\", line 1387, in _gcd_import\n", + " File \"\", line 1360, in _find_and_load\n", + " File \"\", line 1310, in _find_and_load_unlocked\n", + " File \"\", line 488, in _call_with_frames_removed\n", + " File \"\", line 1387, in _gcd_import\n", + " File \"\", line 1360, in _find_and_load\n", + " File \"\", line 1331, in _find_and_load_unlocked\n", + " File \"\", line 935, in _load_unlocked\n", + " File \"\", line 995, in exec_module\n", + " File \"\", line 488, in _call_with_frames_removed\n", + " File \"C:\\Users\\USER\\AppData\\Local\\Temp\\pip-build-env-aze4i1kq\\overlay\\Lib\\site-packages\\setuptools\\__init__.py\", line 16, in \n", + " import setuptools.version\n", + " File \"C:\\Users\\USER\\AppData\\Local\\Temp\\pip-build-env-aze4i1kq\\overlay\\Lib\\site-packages\\setuptools\\version.py\", line 1, in \n", + " import pkg_resources\n", + " File \"C:\\Users\\USER\\AppData\\Local\\Temp\\pip-build-env-aze4i1kq\\overlay\\Lib\\site-packages\\pkg_resources\\__init__.py\", line 2172, in \n", + " register_finder(pkgutil.ImpImporter, find_on_path)\n", + " ^^^^^^^^^^^^^^^^^^^\n", + " AttributeError: module 'pkgutil' has no attribute 'ImpImporter'. Did you mean: 'zipimporter'?\n", + " [end of output]\n", + " \n", + " note: This error originates from a subprocess, and is likely not a problem with pip.\n", + "error: subprocess-exited-with-error\n", + "\n", + "× Getting requirements to build wheel did not run successfully.\n", + "│ exit code: 1\n", + "╰─> See above for output.\n", + "\n", + "note: This error originates from a subprocess, and is likely not a problem with pip.\n", + "\n", + "[notice] A new release of pip is available: 24.0 -> 24.1.1\n", + "[notice] To update, run: python.exe -m pip install --upgrade pip\n", + "WARNING: Failed to remove contents in a temporary directory 'C:\\Users\\USER\\AppData\\Local\\Temp\\pip-install-psn60bj9\\ophys-nway-matching_8ebf834539734420830fb5809b6d6e9e'.\n", + "You can safely remove it manually.\n", + "WARNING: Failed to remove contents in a temporary directory 'C:\\Users\\USER\\AppData\\Local\\Temp\\pip-install-psn60bj9'.\n", + "You can safely remove it manually.\n" + ] + } + ], "source": [ "import warnings\n", "warnings.filterwarnings('ignore')\n", @@ -41,7 +216,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -2874,37 +3049,30 @@ "\n", "Here, we are reproducing Fig 1d-g, where we show that mouse primary visual cortex (V1) neurons respond to illusory contours despite the lack of visual information within their receptive fields. Von der Heydt and colleagues had showed the existence of illusory contours in primate visual cortex {cite}`Vonderheydt1984`, {cite}`Vonderheydt1989`. We are replicating their result in mouse V1.\n", "\n", - "It is important to note that originally we imposed a fixed-gaze restriction; i.e., we only analyzed the trials where the pupil position was within 8 visual degrees of the resting pupil position throughout the duration of the trial. For simplicity, we did not include this condition in this example code." + "It is important to note that originally we imposed a fixed-gaze restriction; i.e., we only analyzed the trials where the pupil position was within 8 visual degrees of the resting pupil position throughout the duration of the trial. For simplicity, we did not include this condition in this example code.\n", + "\n", + "An example session was selected, thus figures may look different from the paper (Shin et al., 2023 bioRxiv)." ] }, { "cell_type": "code", - "execution_count": 47, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File already exists\n", - "Opening file\n" - ] - } - ], + "outputs": [], "source": [ "# uncomment desired files (more will cause a lot of memory consumption)\n", "nwb_paths = [\n", " # \"sub-619293/sub-619293_ses-1184980079_ogen.nwb\",\n", " # \"sub-620333/sub-620333_ses-1188137866_ogen.nwb\",\n", " # \"sub-620334/sub-620334_ses-1189887297_ogen.nwb\",\n", - " \"sub-625545/sub-625545_ses-1182865981_ogen.nwb\",\n", + " # \"sub-625545/sub-625545_ses-1182865981_ogen.nwb\",\n", " # \"sub-625554/sub-625554_ses-1181330601_ogen.nwb\",\n", " # \"sub-619296/sub-619296_ses-1187930705_ogen.nwb\",\n", " # \"sub-625555/sub-625555_ses-1183070926_ogen.nwb\",\n", " # \"sub-630506/sub-630506_ses-1192952695_ogen.nwb\",\n", " # \"sub-631510/sub-631510_ses-1196157974_ogen.nwb\",\n", " # \"sub-631570/sub-631570_ses-1194857009_ogen.nwb\",\n", - " # \"sub-633229/sub-633229_ses-1199247593_ogen.nwb\",\n", + " \"sub-633229/sub-633229_ses-1199247593_ogen.nwb\",\n", " # \"sub-637484/sub-637484_ses-1208667752_ogen.nwb\"\n", " ]\n", "\n", @@ -2923,7 +3091,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -3074,7 +3242,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -3231,7 +3399,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -3255,7 +3423,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -3285,9 +3453,20 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\USER\\AppData\\Local\\Temp\\ipykernel_25308\\3004073138.py:42: UserWarning: last trial was blank\n", + " warnings.warn('last trial was blank')\n", + "C:\\Users\\USER\\AppData\\Local\\Temp\\ipykernel_25308\\3004073138.py:73: UserWarning: check numtrials\n", + " warnings.warn('check numtrials')\n" + ] + } + ], "source": [ "# iterate through sessions and calculate receptive fields for V1 units\n", "\n", @@ -3368,16 +3547,16 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "2" + "5" ] }, - "execution_count": 53, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -3394,7 +3573,7 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -3411,7 +3590,7 @@ " [-143.81038721, -143.81038721]])" ] }, - "execution_count": 54, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -3423,7 +3602,7 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -3442,7 +3621,7 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -3457,7 +3636,7 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -3475,14 +3654,14 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -3519,8 +3698,8 @@ "\n", " # Set the array for the colormap with normalized firing rates\n", " p.set_array(firing_rate_allneurons)\n", - " p.set_clim([0, 8])\n", - " p.set_norm(Normalize(vmin=min(firing_rate_allneurons), vmax=max(firing_rate_allneurons)))\n", + " p.set_clim([0, 10])\n", + " p.set_norm(Normalize(vmin=0, vmax=10))\n", "\n", " # Add the patch collection to the axis\n", " ax.add_collection(p)\n", @@ -3545,7 +3724,7 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -3564,12 +3743,12 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdgAAAGTCAYAAACLRgM2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABiqElEQVR4nO3dd3xUZfY/8M+UTDKppEICAUIvoUnvioAVxYoua0F21V1YC79dy3ctuxZcdNey7q67WLCB2FCxgAIiRUBaAAGB0EIJIYH0Nv33x2EymdSZyb33uffOeb9e9wUMyZ2TzMw99zlPM3g8Hg8YY4wxJimj6AAYY4wxPeIEyxhjjMmAEyxjjDEmA06wjDHGmAw4wTLGGGMy4ATLGGOMyYATLGOMMSYDTrCMMcaYDDjBMsYYYzLgBMsYY4zJgBMsY4wxTXO5XHj88ceRlZUFq9WK7t274+mnn4bolYDNQp+dMcYYa6MFCxbgtddewzvvvIP+/ftj+/btmDVrFhISEnDfffcJi8vAi/0zxhjTsquvvhrt27fHm2++WffYDTfcAKvVivfff19YXFwiZowxpjo2mw3l5eV+h81ma/Jrx4wZgzVr1uDQoUMAgN27d2Pjxo244oorlAy5ES4RM8YYk8Rtyckoc7kkOVdely7Ys2eP32NPPvkk/vKXvzT62kceeQTl5eXo06cPTCYTXC4Xnn32WcycOVOSWELFCZYxxpgkytxuLO/VS5JzXZ2Whg0bNvg9FhkZ2eTXfvTRR1i8eDGWLFmC/v37Y9euXXjggQeQkZGBO+64Q5J4QsEJljHGmOoYjUbEx8cH9LV/+tOf8Mgjj+CWW24BAAwYMAB5eXl47rnnOMEyxhjTCYNB8aesrq6G0eg/pMhkMsHtdiseS32cYBljjEnDYACMyo+dnTZtGp599ll07twZ/fv3R05ODl588UXcddddisdSHydYxhhjmvbqq6/i8ccfx+9//3sUFhYiIyMD99xzD5544gmhcfE8WMYYY5K4JikJy/v2leZcyclYvny5JOcShVuwjDHGpCOgD1atOMGysOF2A2VlQGkpUFwMlJQAtbWA0wl46zgmEx3x8UBiou+IjhYaOmNMgzjBMl0qLAQOHwaOHgWOHAFOn6bkGuoc+KgoIDkZ6NoV6N6djqwsTryM+RE0yEmtOMEyXSgsBLZtA3JyKLFWVkp7/tpaStKnTwM//kiPGQxAhw5A377AsGHAoEFAM/PgGQsfXCKuwwmWaZLHA+TmAtu3U2I9eVJMDGfO0PH994DFAmRnU7IdPpxKy4yFFW7B+uEEyzSlshJYuxb47jtKbGpitwM7d9LxxhvARRcBl10GDB7MN/WMhSNOsEwTjh4FVqyg8qzdLjqa1rnd1Lrevp3KyFOnApMmAbGxoiNjTGZ8N1mHEyxTtQMHgCVLgP37RUcSuoIC4N13gaVLKdHecAMQFyc6KsZkwCViP5xgmSqdOEGJdft20ZFIx24HvvqK+muvvRa4+moeFMWYnnGCZapSVEQtvQ0bqMyqR9XVwAcfUMn7ppuAKVP4pp/pCL+Z63CCZarg8dDApffeoykx4aC0FHj9dWrRzp0LZGaKjoixNjIYuA+2Hk6wTLjCQuA//wH27hUdiRhHjgAPPUSt2enTuQHAmF5wgmXChGOrtTkOB/U5//QTt2aZxvEdYh3+TTAhamqAv/+dSqThnlzr87Zm160THQljIfCWiKU4dIATLFNcYSHw5z9Ta4015nAAr75KLXu9DvRiLBxwiZgpat8+arlWVIiORP2++IKWgLz/fiAmRnQ0jAWIS8R1+DfBFPPdd8BTT3FyDcbOncD//R8tVsGY6nkXmpDi0AF9/BRM9T7/HFi4MPTt4sLZ6dPA448Dp06JjoSxAHAfbB1OsEx2H30EvP++6Ci0raQEePJJIC9PdCSMsUBxgmWy+vRTSrCs7crKqMTOLVmmWlwi9qOPn4Kp0ldf0ZKATDplZcBf/6q+rfoYq8Ml4jqcYJksfvoJeOcd0VHoU0kJ8NxzQFWV6EgYYy3hBMskd/w4zeP0eERHol/5+cDLL/M8WaYyXCL2o4+fgqlGeTnw/PO8OpMScnJoMQrGVIUTbB19/BRMFZxOWkSisFB0JOHjyy+BH34QHQVjrCmcYJlkFi8G9u8XHUX4+d//qCzPmHC8FrEfTrBMEr/8Anz9tegowpPDQdv98SIeTBW4RFxHHz8FE8pupws8D7gR5+hRYNky0VEwxurjBMvabMkSnpepBp98wqViJhiXiP1wgmVt8ssvwDffiI6CAVQi5lIxE45LxHX08VMwIdxuWsCfS8PqcfQosHKl6ChY2OJ5sH708VMwIdavp/1Kmbp8+ilQUyM6CsYYJ1gWErsd+PBD0VGwppSX0/xYxoTgPtg6nGBZSL77DigqEh0Fa87y5bQxAGOK4hKxH338FExRNTVUhmTqVVvLrxFjonGC1Ri3m8qztbW0m0p1Nf3d6VQuhm+/BSoqlHs+FppVq5RrxXo8gM1GN1+VlXTU1NAiGCzMcIm4jll0AMyfxwOcOwecOAGcPUv9aWVl9Kf3aG6XmshIID4eSEjw/ZmYCHTqREdUVNvjc7upPMzUz+EA1qwBrr9emvMVFQHHjgGnTwPFxUBpKR0lJfS+bO4mLyoKaNfOdyQmAklJQJcuQNeuQGysNPExFfCWiBkATrDCVVcDBw8CeXk0IvfkydB3orHZ6CLYVN+owQCkpgKdOwOZmUCPHvRnsHJyeDF/LVm1Cpg+PfhrXm0tsG8fcPgwJdVjx0KvWtTWAgUFdDQlLQ3IygK6dQN696b3Jl+jmR5wghXg3Dng55+BvXuBI0eUmUfq8VBiLCwEtm+nxxISgOxsYMAAoGdPICKi9fN8+628cTJpFRUBO3YAw4e3/rXFxfS1O3fSpg1KlXe978uffqJ/x8cDQ4YAF11E700pKi9MQXx3VIcTrEIqKoBNm+gC1tydvNLKyoAff6QjMhLo0wcYO5ZaEU11gRQWArt2KR4ma6Pvvms+wVZV0XzmH3+kRSrUoLwcWLeOjogIugm85BJKuHzt1gCd9J9KgROszI4cATZsAHbvVvcSdjYbxbh7N5WSx40DRo4EoqN9X7N6Na/apEW7dtHNUVqa77Hjxynxbt5Mr71aORzULZGTAyQnA5Mm0ZGQIDoyxlrHCVYGbjewdStthJ2fLzqa4BUVAZ99Bnz1FTB0KDBlCiXdbdtER8ZC4fHQa3fllfS+/OYbIDdXdFTBO38e+Phjem+OGAFMm0YDpZiK8CAnP5xgJbZrFyUmPQwEcjiALVvoojxgAI1s5uqPNnlbq2opA7eF00ndLVu2AKNHAzfd5N86Z4LxRaIOJ1iJHDpEq+ecOCE6Eum53dQfVlsLmM108GdIG2w2Grx07BiNzjWZREckHbeb+o5/+gm49FIaLc2lY8G4BeuHE2wblZYCH31EI4L1rLqa/nQ66YiIoETL1MntppJqZaVv3nRVFY3Q1Runk0a3r1tHrdnLLuNrPFMHvkS2wZYt1B+k951LXK7GP6PDQY9bLNyaVZvqapoK1nDhh8pKfSZYr9pa4L33qEvj7ruB9HTREYUhbsH64QQbgtJSYOlSmisYDppb+MLtpv/j1qw6uN2UWCsrm/5/vd8Ieh08CDz6KDBjBrdmheA77jp8WQxSTg4l13C5WAGtT+Pg1qx4NTU0+rulNakdDvr/cLgZstt9rdk//IGWZmRMaXxvFyCPh0YHL1oUXskVCGyepNtNX8fzZJVXVkaLlwSy4UOoy3Bq1cGDwOOP03x0pgDers6PPn4KmdXWAm+8Eb6L3Ae6EIF3RxU1L6ihJ96NIc6fb34DiIbCLcECtBnBU0/Rgi9MAbybTp0wKBa1zfnzwMKFwJkzoiMRw+kMPmHa7VSGDGRtYxYal4t2Wwo2YYZjggWoPP7aa7SZxi236KaBxFSOE2wLTp0C/vOf5geNhAO7PbTvczqpVRURoZubUdVwOumGL5TF+NW8LKISvIvAzJ0bHn3RQvDdSx3+TTQjLw/417/CO7kCbdtRxeWi7w+0fMla53DQ8puhvi7eG59wtnUr8PLLvBm8LLgP1g/fwzXhxAng3/8O33JafW3tT/V+vxpbskVFP2D9+kua/L+LL96M5ORRCkfUMoeDWq6BDGZqjsdDr0m4t9527gRefBGYN4+7Mph8wvxj1tjp01QW5uRKpBiw5D2HxdL2c8mhe/f7kJTkv59bbGwPQdE0zVsWbktyrX+ucE+wAO0c9eqrwP3362sJSeHUdictEH/M6ikuppard1lAJs0FHfCVi9XYWkhJGY9OnW4UHUaz3G7pkisg3Xn0YPt24PXXgXvvFR2JTvBKTn74N3GBzUYftHDvc21Iyik33nWM1cjhqIDbrb7gPB4aLSxlf6FaXwNR1q8Hvv5adBQ6wtN06nALFnQRe/99Kg8zf1LPaXU41DeGYceOWXA6K2EwmJCSMh4DBryAxMRhosMCQFUVqRc24XnKjX3wAdCxIzB4sOhImJ6o6DInzsqV1B/DGpNjxKndro6RrEajBR073oBBg17B6NFfoH//Z1BW9jN++GE8SktzRIeHigpapUlqavjdq43bTbMG8vNFR6JxPIrYjz5+ijbYswdYsUJ0FOHF41FHkk1OHoNRoz5B1653ISPjGvTu/QguuWQLDAYD9u59VGhstbW0SpMcRP/e1aq6GvjHP8JvKVTJcYKto4+fIkQVFVQaYs2T62LsdquzLzA2tgfS069FUdFaeDxiaqluNy3cz4lQeWfOUHcRY1II6wT70Ue0CTVrnpxjDZxOdW4OEB2dCbfbDqdTzJujpETeRRB0Mn5ENmvXUmWLhUCqAU46eZOGbYLdsYP7XdVADaXihqqqjsJojILZHKv4c9fWAuXl8j6HTq5dsnr9dS4Vh4xLxHX08VMEqaIC+OQT0VFog9zvc49HXKnYZitq9Fhp6W7k5y9H+/ZTYTAo+/FQqjTMCbZ1589zqZi1XVhO0/n0Uy4NB8pkkn/NVqeTnkfpm9affpoBk8mK5OQxiIxMQ3n5fhw7thBmczSys/+mbDCQvzTsxas4BWbtWmDMGKB/f9GRaIiOyrtSCLsWbF4erUPKAqPUxVjEwusZGdNhs51Dbu6LyMn5PU6d+hAdO16PSZO2Iz6+r6KxOJ3yl4a9OMEG7oMP1NeFoXpcIq4Tdh+15ctFR6AtSq3R6nbTAghKrgnbo8d96NHjPuWesAXFxcpdyDnBBu7oUeCnn4BR6tr3gWmEPm4TAvTLL0BurugotEXJi7Eap+0owW5XtsuCE2xwPv6YV78KGI8i9hM2Cdbj4dZrKJS8GHtbseFGydarjqpvijlzBvjhB9FRaAiXiOvo46cIwK5dvNZwKJTe/SbcNsGurVV29ya1bhmodsuWhd97MyS8VKIfffwUAeA70NBYLMpWa7wbgocLpQY2eUVFKft8elFSAmzZIjoKpjVhkWBPnwaOHRMdhTYZDMq3esIlwbpcyk8X4wQbujVrREegEdwHWycsEuzGjaIj0LbISGWfz+UKj6kR5eXK/5ycYEN36BBN82Mt4BKxH338FC2orQW2bxcdhbYpnWCB8BhRXFGh7PMZjWJeSz1ZtUp0BExLdJ9gt20DbDbRUWibiIuy3lux1dXK30RERuqm8ibMpk3KDkrTJC4R19F9gt2xQ3QE2hcZqewCEAAlVzXutCOVykrlnzMmRvnn1JvaWr6mtIhLxH708VM0o7KSBzdJRcTFWa8J1uMR0wqKVX5zIF3ipVZZoHS9psv+/fouMyopJkb5KSUul/LzcJVQW6v8zUNEBA9wksqePVTe5xWxmqGT1qcUdP2b+Pln0RHoR1SU8t0iei0Tc+tV22pqaNlV1gReKtGPbhOswwEcOCA6Cv0wGoHoaOWfV49zYjnBah/3w7JA6LbIcewYjx6WWmys8gsj6K0F63Aov+Se2Szm5kjP9uwRHYGKcYm4jm5/EydOiI5Af2JilB9N7Hbrqx9dxE1fu3a6qbipRkGB8jebmiGoRHz69Gn8+te/RnJyMqxWKwYMGIDtghdB0G0L9uRJ0RHoj8EAxMfTuqxK8nj0kyCUTrAGA5CQoOxzhovjx4H+/UVHoTLeaToKKykpwdixY3HJJZdgxYoVSE1NRW5uLhITExWPpT5OsCwoIhKs262fqpPdruzzxcbqcyS2Ghw9yglWLRYsWIDMzEwsWrSo7rGsrCyBERGdXLb8VVcD586JjkKfzGbl58RyiTh07dop+3zhhOfYN0HChSbcbjfKy8v9DlszH6Dly5dj2LBhuOmmm5CWloYhQ4bg9ddfV/iHb0yXCZZbr/JSuuSol4FODoeyP0tkJA9ukhMn2GZI1Aebm5uLhIQEv+O5555r8imPHj2K1157DT179sS3336L3/3ud7jvvvvwzjvvKPzD+9NlibiwUHQE+ma10oVbqekmekqwSkpN1U/ftRoVFdE0MqUH/oWLnj17Ytu2bX6PRTazMLrb7cawYcMwf/58AMCQIUOwd+9e/Pe//8Udd9whe6zN0WWCVXrFIREKC3di69a/ID9/I1yuWsTHd0N29t0YNOg+RZ4/KUnZ+Zx6GOik5OL+0dFi577u2/cs9ux5DAkJ/XHllXvFBSIjtxsoK6PPArtAwkFORqMR8fHxAX1teno6+vXr5/dY37598emnn0oSS6g4wWrQiRPf4csvpyE1dQiGD38cERGxKCs7gsrKU4rFEBlJF3ARi9ZrlZKLZqSkKPdcDVVXn8K+ffNhNut/d4GSEk6wjQi4Ex47diwOHjzo99ihQ4fQpUsXxWOpT5cJtqxMdATysdvLsWrV7eja9SpceeUnMBjEdaMnJdFcQCUGIemhBatUgo2NFdv3mpPzR6SkjILH44LNpu/RhqWloiNgAPDggw9izJgxmD9/Pm6++WZs3boVCxcuxMKFC4XGpctBTnpOsAcPLkF19VmMHv0sDAYjHI4qeDxiOikjIpQb8KSHkcRKlIgNBup7FaWwcD1OnvwEF130srggFMQJtgFB29UNHz4cn332GT744ANkZ2fj6aefxssvv4yZM2fK9IMGRpct2IoK0RHI5+TJ1bBY4lFZeRpffz0dpaWHEBERg969b8P48S/BbFZ2y5TERGrFyj2ARw8JVokWbEoKle9FcLtd2LHjD+je/Tdo126AmCAUxgm2CYImrV999dW4+uqrhTx3c3TZgtXzGsSlpblwu534+utr0bnzZbjiik/Rt+9d2Lv3v1i9epbi8RiNYltMWiL3aOioKLH9gYcP/xdVVXkYMOBpcUEoTM/XGtZ2umzB6mVaR1Mcjko4ndXIzr4XEyf+EwDQo8f1cLvt2Lv3fxg16im0a9dT0ZisVioVy1ma10MLVk4GA5CeLq6f2mY7j59/fgL9+z+OqKjwuePS425Pbab1wRIS0mULVs8J1my2AgB69brV7/FevX4FADhzZrPiMQHUcuIl+cQRWRoGgD17HoPFkoRevf4gLggB+MavAUF9sGqlj5+iAZ28Nk2KickAAERHt/d73GpNAwDYbAovFHyB0QikpfHNqwjR0WJLwxUVuThyZCF6974PNTX5qKw8jsrK43C5auF2O1BZeRw2W7G4AGXE7/cm8IbrdXRZItZzgk1LG4qTJ1ehsvI0EhN71z1eVZUPALBaxZXnoqKoP1aOlbR08nmTXEQEkJEh9vdTXX0aHo8bO3bchx07Gi908uWXWejV634MHfqy8sHJjFdxYi3RZYI1m/U7+KBnz5uxY8ffsH//m8jMnFT3+P79b8BoNKNjx4vFBQcgLo52jOHRlY1JnQSNRqBjR3q/i9SuXTbGj/+s0eN79jwGh6MCQ4e+gtjY7gIik5/o373qCNquTq10+faIjdXvZsipqUPQr99d2L//LbjdTnTsOBGnT/+Aw4c/xtChjyI2NkN0iEhKoiQr5VKKemjBStna8Q5qilJ2VlaTIiNT0KnT9EaPHzz4MgA0+X96ERcnOgKV4QTrR5cJNiEBOHtWdBTyufji/yI2tjN++WURjh79DHFxXTB+/EsYPPgB0aEBoM9YWhqQn6/8/qdqJmVrJzmZL+5qIHg/b6ZyukywAa4PrVkmUwRGjnwSI0c+KTqUZplM1MLKz5dmEQpuwfokJYldazhQl176g+gQZMcJtgl6+LBKRJcJVun9SlnTzGYagHP6dNuXCdTDZ1aKBJuYSNUBpg6cYJvAJeI6uvxN6L0FqyXeJNvWObJ6SLBtLREnJgLt27f+dUw57dqJjoCpmS4TbHKy6AhYfd6pJBZLaN+vh+QKtC3BJidzclWb+PjQ39O6JdUcWJ186HVZIu7USXQErCFvS7awMPjRxXqpOFksdN0IZvUfg4ESK7eU1KdrV9ERqJRePrAS0OVvIikJiNH/Xs+aYzIBHToEnyz08nk1GIIrlZvNQGYmJ1e16tZNdARM7XRy6WosM1N0BKwpBgOVO4NZVlEvCRYIfL3gqCigSxexG6ezlnELtgm8FrEfffwUTejcWXQErCVxcYEPftJJdwyAwBJsQgK9f3nzBHXjFmwzuA+2ji77YAHuh9WCqCh6nYqLm9/qTkefNQAtJ1izmUrosbHKxcNCExenjbnIiuOVnPzoNsH26BH8gBKmPKORLlQxMUBRUeNFKfS2mLrFQj9zwy0VExKobK63n1ev+vUTHQHTAt3easTGAllZoqNggbJaqTXbcJEQvd0MGwz+/aoREfRzp6dzctWSiy4SHYGKcYm4jm5bsACQnQ0cPSo6ChYob2s2Ph4oKaENG/SWYAFKsDU1NNirXTt9/ox6ZjQCQ4aIjkKluETsR9e/iQEDREfAQmGx0NzPSy8FBg8WHY20oqKAW28Fevak6WR8LdKe3r25n5wFRtct2PbtaQPwoiLRkbBQTJgADB0K7NsHfPklsHNn475LrYiPpxuGq66iVuuJE8Avv4iOioWCy8Ot4LvGOrpOsAAwaBCwerXoKFiwzGbfQJL+/ekoLARWrQK+/775Ucdq07s3cNllwOjR/tNuRozgBKtFBgMwfLjoKFRMR/2nUtB9gh0zhhOsFl10EQ18qi8tDZg5E7j5ZmDLFmD9emDvXmm2w5NSUhJdhCdPbn6g3bhxwNKlgM2mbGysbbKzeTcjFjjdJ9iUFKBvX24taM348c3/X0QE/f/48TRYaPduYMcOOsrLlYuxvqwsSqrDhgW2AEFMDDBqFLBunfyxMelMmSI6Ag3gEnEd3SdYgFoLnGC1o3NnWiYwEFYrJapRo6h/9vBhOo4coRHkp09L329rtVIS7dYN6N6dbuBC2cFp6lROsFqSksL9r63iErGfsEiw/fvTXpolJW0/l8dDB7+P5DNuXGjfZzQCvXrR4WWzAcePAydP0utfWkorR5WU0FFbC7hcHrhc9HqaTAaYzbRST2Ki/5GcTC3V9HRpXvusLErQR460/VxMfpMmceOMBScsEqzRSBftL79s/ms8HroY19QAdjvgdFLfXv0/m1oVymikATkREXR4/26xUEuH94sMTnS0tK2ESIsHvXu40bu7x3d3VP9ojjeDNpz8bjQCMFw42m7qVOC11yQ5VVix2+nz6nLRZ9Pl8v3d7W7+s2oy0WE2+/4eEUFLWLa00EdEBHDJJfL9PLrCdyF1wiLBAtRft3YtUFlJ/7bbaSGD6mpKqrW1oZUS3W46l93e9P+bzZRorVZKHjExvGJPSy69tA03JR4PvSDeK2xzV9pAz1X/z4aa2jUkBGPGAJ9/Dpw5E1qY4cDhoM+nzeb7rIXysnrfGs0NijOZKNF6j6go333WpZc2XmWMNYFLe37CJsFGRtKUnU8/pYEwtbXKPK/TCVRU0AHQey8mhuZFxsdzC7e+hARg4sQgv8njoaaL201/KsX7vN7npPqyL9kGeJExmYCbbgL++U8ZY9Wg2lq6+a2uVm6UuMvle06AXkKrleYtT5qkTAy6oOEW7DXXXIO77roL06ZNg0mClpDuE+yJE8APPwDbt1OfW3ExJT1RPB5qRVdWAvn5dJfcrh1N7TDr/tVo2eWXB3jDUT+5qWXlCY/H/43lrT8G8CEdOZIGTIX7sp42G92IVlWp42X1eCjZWizAww9Tf/nYsVQN43169enrr7/GV199hfbt2+O2227D7Nmz0bt375DPp8tLutMJbN0KrFkD5Ob6HjcYqJV0/ry42BqqrQUKCoCzZym25GRq4YabtDRajKFFbrevw03tvDcABoOvw6+ZVq3BANxyCzB/vsIxqoD3hrO8vPluFpFMJvpcejy+EeoffkiJdvLkwEe7hw0drEW8evVq7Nu3D4sXL8Y//vEPjB49GnfddRdmzJiBmCAvzrpKsJWVwIoVNPWhufmQ0dH0f2pbnMDjoRGupaVUlkpOppGr4dKdcdVVLXwu649e0RqPh95sDodvdE0TP2h2Nh179wqIUQCXi1bjqqhQ98va1GYMtbV0875mDY1Yv+IKWpkrXD6rrdL4L6J9+/aYNGkS/vCHP+DIkSNYvHgxFixYgAceeAAzZszA7NmzMWrUqIDOpe1bjQtqa4EvvgDmzaORwi0tNmAwUDlWzWpqgFOngEOHtLMkYFv079/M7iQul29ki5qvwoHy/jwOR5OjdGbN0n+fvNtN3TQnT9J7W80va2QkTddqyaFDwCuvAI8/Hj43R+Gke/fueOKJJ3Dw4EF8//33qKmpwZgxYwL+fk23YJ1OGhm8fHlwiSgykgYYiVr1J1A2G5CXR63uDh30uYOH1QrMmNHgQe9QTzVffdvC6aTDbKbjwh1/ejr9Lt57T3B8MvB46PNWWqqNl9VgoIUlAm2MHT1KJf7sbHoNu3eXNz7V0kGJuKGqqip8/vnnWLJkCdauXYurrroq4O/VbILdtw9YtIgWgA9FQgINYBA54ClQ1dX0AY6LAzp21Fcr5/rrqQwHwFdO1UIfqxS8idY7gRq0McDWrcDBg4Jjk1BVFY170NLL2q5daJ+zvXvpGDsWuP321lvAuqTxErHH44HT6cR3332HxYsX44svvkB6ejpmz56NN998Ex06dAj4XJpLsLW1wAcfUMu1LQwG6uc8e1aauJRQUUElqYwM9Ze5A9G/P42gBUBX32ZKp7rnvamwWGA0GnD33cCjj6pz0E8w3G7g3DlKsFoSGdn2Oa8//kiJdtYs6p9l2vHkk09iw4YNqK6uxg033IBvvvkGEyZMCOlcmkqw+/YBb7wh3ShgrZSK63O7qX+2rEzbrdno6Aul4XBrtTbH7aa7x4gIpKebceutwDvviA4qdFpstQLBl4ZbUlYGvPwyjY6/884wac1qvERsMBhw6tQpPPPMM7j11lsR18YXTRMJ1ukEliyRZ9u5hARqKSi18IRUvK3Zjh1ptLGWGI3A7NlAuzgXYAvTVmtzLtxsXDbVgiNHDNi4UXRAwfF4qNXqXTFNa1JSpL9p3bwZ2L8fuOceYPBgac+tShpOsLt27UJ2drZk51N9gi0rA159lZKJHLx3rAUF2uiPrc/tptGYtbU0CEorXR833AD0zHICdpXNlVILtxuw2fDb2RYUFBhx+LDogALjdFKXi1ZL2wkJ8g0kLCsD/v53qtpMmybPc7C2i4uLQ15eXqtf1yXACdCqTrDHj9MQeLkXhjAagdRUSrJabEwVFVGS7dxZ/escjx3jwfiRDsChsdqh0jweRHhsePB+Cx57wiTJTlByqq2l5KqFEcJNiY6WvxLkdtP4kZMngd/+lsa26ZJW7vSb0K1bN3g8HhgMBniaSAbex90BvtFVm2B/+gl4/XXl7oYjIqglW1SkzPNJraKCVpnp2pX6ltWoe3cPbrzGDrg0ehUWIDHajnn3ReCp+WbVLY7iVV6urtXRghURQTfYSuWFjRtpc4cHH9THYEU/Gu+DzcnJ8fv3qVOncPPNN2PTpk0AgOLiYkwKYmFqVSbYFSvoTk9pViu94YuLlX9uKdhslGSzstS3VmpGuge/uc0Gk0GDJQLBund24A/3evDKf8xwudTVOigu1vZiKGYzda8onROOHAGeeAL4859p/rOuaLgFO3DgQL9/x8bGwmAw1D1eGOS8UNXdaixfLia5esXGam/QUH0uF82ZVdPUiPZpHsz5rQ0xVk6uoRo22Inf/9YJo1E9v8Pz57WdXE0mSq6iNtkoLgaefppmBTB9UlWC/fxz4JNPREdBw+nrFj/QILcbOHZMHUm2fZoHc++2IS5GPYlBq0YPd+J3Kkmy589ra3pbQyYTtRxF94OWluosyTa1T3Koh0oYGrTIG/67Jar5Kb7+Gli2THQUPvHx2m7JepOsd29LETLSPbjvXhsS4sQnBL0YO8KJ+37vhNkk7ndaXKzt5Go2qyO5elVUAM8+S9tXap7OEmxmZiY2bNhQ92+r1YqZM2cG/P2q6INdt462gFKbuDh6nYuLtTm62Jtke/RQfuBTz54e3DWTy8JyGDHEiT8+aMCrr5kVr1KUlmq7LGyxAO3bq2/v5bIyWsv46ae1fWOvdevWrWvx8YkTJ+Ktt97CunXrMHHixFbPJ/xtdvAg8PbboqNoXkwMfRjPndPeqjQAxXz8OCVZpabwjB/nwfVX23lAk4wG9nXgqSeBv79kxpkzyjxndTVUP12oJTExNFNAJY2jRoqLgZdeop151NK6DomGBzlNmjSpbppOQ97pOd6RxK4AEoLQt9q5c7SIhNoTV2QkDYZQ6/SX1thswIkT8rfCjUaaSH/TdAdMBp6KI7f0ZAee/qsbgwbJ/1x2e+gba6hBYiKQlqbe5Op1+DAtB6tZGi8Rl5SUoLS0FCUlJY2O0tJSAEBaWhpKArzTFNaCtdlonU6t9OWYTPQBLS5Wx+ChYFVU0EIack0JiI2l5Q+7d3HyIhIKijbb8ac/RmLphwZ89ZU8z+F20yISWuwmMRjoc6u2aWst2bAB6NIFuPJK0ZGEn/j4eEm/TliCff11alVpiXcHnqgoKpVpbdWaoiKKXeo+nkGDgJtvBuKiXbz8odI8HhiddvzqVguysw14/XXpF304e1Z7y4gC9F5PSdFmuXXJEqBTJ6DBtExt0HCJ+J1Wdti44447gjqfkAS7YQPtealVMTG+JCtylG4oTp+m+KVY0DwmhhLrkCGg5o2Nk6sQbjfgdGLgwAg8/zzw/vtt387Rq6xMexthGAy0YEyAjQxVcruB//0PWLBAvvWRZaP2OnwLHnzwQb9/19TUwG63w2w2Izo6OugEq/hvorgYWLxY6WeVnslEd8fJydp6P3m3u2urQYOA//u/C8kVCN+9XNXC6QTcblittM7tww/Te7MtHA7tDWqKiqIdprScXL1KSoB33xUdRZA03gdbXFzsd9TU1GD37t0YMWIE3g3hxVD8p3jrLe21+loSE0P9mnFx2qmMVFaGXkbs2BG4917qb63bKtHlUv9ItXBgt9fd5AwaBDz/PO1cFBUV2umKirRzz+RdT7hDB22WhJuzcSOwY4foKMJbdnY2XnjhBTzyyCNBf6+iJeL164E9e5R8RmWYTNSvGRdHJTUtDII6c4biDbRUnJICXHUVcNFFDW4kvBumM/E8HmrJXsgwVisl2ClTaJW01asD70stLaWBiGpnMtGqa1q6wQ3Wm28CvXtrqFSswxciOTkZubm5cLvdMAbRulYswZaVUce9npnNVJaLj6efV80tdW+puFu3lr8uIQGYOhUYM6aZebRcGlYXp5NeqHoXgfh44PbbgSuuAD79FNi0qeVE63BQglUzo5Hem/Hx2uqiCUVpKfWr33uv6EgCoPHddJrTqVMnHD58OKhlEgEFE+wXX6g74UjJu/Wd00nl2MpKdY44rqyk6Tt1pd56evUCxo0DBgxoYYEKt5tLw2rkcDQ5aTs1lS7St9wCfP89HU3tHFVSot57pshISqoxMbpsKDVrwwa6QQpwn28WolmzZrX4/4sWLUJFRQXuu+8+LFq0qNXzKZJgz56VblSjlpjNVL5KSKCbi8pK9ZXdCgqo9GQwUElx+HBg/HhaTq5VWpy7EQ68Nz7N3Bm1awdcfz0wfTr1761aBezbd2EguE19XRwGA71H4+K0u9hLW3k8wNKlNHhN9TR851MWwDqgHo8noK8DFEqwn34a3g0dg4HuuGNiKCfV1NChhukPdjuQmQlMmwb07BnEGq3celU3b6m4BUYj3VANH06t1p07gf/+l96voluwJhPd8HmnxOmw6hi03buBX34B+vYVHUkLNF4iXhbAjjPx8fEBfR2gQILNywO2bJH7WbTDbKY78bg4ylHeRGu3KzNWyGikgU2RkXQBs1hotGhQyRXggU1q10ortqHERN+iDJ07+24CbTZ6b8rNYKD3ZGQkrboUGanphpBsli4F/vpX0VGwQMmeYNWwv6taGY2+li1A10SHgy5qDgcdoc6AMRjo2mo2UxKNiPD92dDZszTCe9KkAE/ucqmzU5n5czjoTRZgpvroI/qz4fvSWzq2233vTacz9Pel2UzvTe+Nnvd9yQm1dbm5VNYfOlR0JC3QcAvWu9h/c9YG2dcpa4ItKKCyBguM0ei7i6/P4/E1SJrLbd7KjMnUaBBpQFatCiLBct+rNnjfOAG0Yg8coK0Nm2IwUJm24Xxa7+m9ydb7vvR4fMnS+770JlUNX3tVY+VKFSdYg0HTd0qDBw/2+7fD4cCePXuwZ88e3H777UGfT9YEu2aNnGcPH97WqJzbzZ0+HWD/jtvNrVctCaAvFqAbrGAp8b5kje3bR5uzZ2SIjkR/XnzxxSYff/rpp1FZWRn0+WS7n7TZaGg5047VqwP4Ih7YpC0B3BCVlQHbtikUD5NEQJ9VUTS8VGJzfvWrX+GNEPYRlO2n2LIlfOa96sXOna0sMOBdKYhpSys3Rd9/zy+r1qxfr74pfwB8JWIpDhXZtGkTLCHskCJbiZjLw9rjctF85euua+ELmPY4ndQJ2sRFy+2mBMu0pboa+PHHIMZNKEllrc9gXNfg4ufxeHDmzBls374dTzzxRNDnkyXBFhQAx4/LcWYmty1bOMHqUjODnQ4elH7/WKaMTZtUmmA1LLHBZtlGoxH9+vXD/PnzcemllwZ9PlkS7M6dcpyVKeHMGbpB6tChwX94h4wybWpmTizv1KJdBw/Sqlve6VSqoPGFJt566y1JzydLgs3JkeOsTCk5ObTuqR9OrtrmdvvPn7mAP6va5XLRNMgxY0RH0oDK+k+D5Xa7sWrVKhw8eBAA0KtXL0ydOjWoXXS8JE+wlZXAoUNSn5UpaefOJhIsl4e1zeNplGDz86liwbRrxw4VJliNee+99xAXF4fp06fj0KFDuPbaa3H06FFkZmYCAE6ePImsrCx88cUX6N27d1Dnlrwtv3u3+HVMWdvk5tKNUh0uD+tDg5skLg9r3549KhsB7i0Ra2iazjPPPIPYC5vt/uY3v0HXrl1x6tQpHD58GIcPH8apU6eQlZWF2bNnB31uyVuwetxQPdy43TSZfeTICw94Wz9M2xrcJPEqa9pXVQUcPgz06SM6kno0ViI+efIkevbsCQDYtm0btm7ditTU1Lr/T01NxQsvvIDhw4cHfW7JbxOOHpX6jEyEI0fq/YNbr/rg7YcF/dHc0ohMW/w+qyxoKSkpyM3NBQB069YN5eXljb6mvLwc3bt3D/rckibY6mpaOJ5pn980K06w+nEhwZ45Q7vlMO1T1Y2SBkvEU6ZMwQMPPIAff/wRL7zwAv70pz9hzZo1qKioQEVFBdasWYN58+bhlVdeCfrckpaIee6rfhw/Xm9MDCdY/XC7AaNRXRdl1iaqey01Nk3n73//O6ZPn44JEybA4/HAYDBgypQpfl/jfcwd5LWQEyxrUm0tVSM6tOf+V125cIFQ3UWZhayggKoRVqvoSLQpMTER69atw7Fjx3D48GHU1ta2uGVdMCRNsPyh1Zfjx4EOaZxcdYUTrO54PPRZbXUnLCWocB3hQGVlZSErK0vSc0raluc5dfqSnw8uD+tNvT5Yph/5+aIjqEdjfbBykrQF2+JOLBr244934ujRd5r9/xtuOIXo6I4KRqSMsjLovjxss9nwxNNP470lS1BSWoqB2dl45sknMSWEdUe1wu3yoLxcm62M1pSV7cPPP/8FxcU7UFtbAJMpGgkJ/dC375/QseM00eHJRjXXXg23YOUgWYJ1u4GKCqnOpi69et2D9PTJDR71YMuWexEb21WXyRVQ0YdWRnfefTc++ewzPDB3Lnp27463338fV153HdauXIlxOl0ip7TUA7dbnxfBqqo8OBwVyMq6A1ZrBlyuapw8+SnWr78Gw4f/Dz163C06RFmEw2dViyRLsGVl+m3spKaORmrqaL/HCgs3wuWqRlbWTEFRya+kBPp9UQFs3bYNSz/+GC/Mn48/PvAAAOD2mTORPWwYHvrzn7Fp7VqxAcqktES/r2lGxpXIyLjS77GePefi22+H4sCBF3WbYEtKREdQj07Ku1KQ7DehqhdYAceOLQFgQFbWr0SHIpvSUug6wX7y+ecwmUy4+6676h6LiorC7DvuwOaffsLJU6cERiefkmL9vqZNMRpNiI7OhMNRKjoU2aimBavBebBykrQFGy7cbgfy8j5CauoYxMZ2FR2ObMrKqL/OqM9qInJ270avnj0RHx/v9/iIYcMAALt270Zmp04iQpNVWZlOX9B6nM4quFw1sNvLcPr0cpw5swKdO88QHZZswq2B05K//e1vePTRR3H//ffj5ZdfDup7Z82aFdDXLVq0KKCvkyzB2mxSnUn98vO/hc12XtflYYAar04nYIkQHYk8zhQUIL3Rxreoeyxfp0NtbbX6b8Hm5Pw/HD78PwCAwWBEp07XY9iwfwmOSj6quv4KHOS0bds2/O9//8PAgQND+v6yBi3FqqoqfP/995g2jQbI2Ww2rFixQvkEG067mR07tgRGYwS6dr1ZdCiyczk9gE4TbE1NDSItlkaPR0VF0f/X1iodkiKcYfBZ7d37AWRm3oiamnycOPERPB4XXC676LBko5rrr8AN1ysrKzFz5ky8/vrreOaZZ0I6x7Jly/z+fezYMQwcOLDu8aKiInRo4qa8OZL9JsJluqTDUYmTJ79AevpliIxMFh2O7Fw6fl2tVits9sYX3doLidV6IdHqjY671evEx/dBhw6TkZV1OyZO/ApOZyXWr58m2Qo9aqPH66/b7UZ5ebnfYWuhqT5nzhxcddVVmDy54YyP0FVWVsJZbz9Au90Ok8kU8PdLlmB10ifdqpMnP9f96OH69Nr/ClAp+ExBQaPHvY9lpKcrHZIiwnGaYmbmjSgu3oaKikOiQ5GFml5TDwySHLm5uUhISPA7nnvuuSafc+nSpdi5c2ez/x/Sz+Hx4KWXXoLNZsPevXsBADt27ECnIMZlSFYiDpcEe+zYYpjNscjMvEZ0KIowmg0A9HnXP3jgQKxdtw7l5eV+A51+2raN/n/QIFGhySqIG3DdcLlo6yCHQ5+jMdVy/fV4pGtN9+zZE9sufBa9IiMjG33dyZMncf/992PVqlV13Ttt4XK58PHHH2P+/PkYNWoUTCYTpk6dijFjxmD16tW45557Aj6XZC+LWfKt29WntrYIZ86sRufO18FsjhYdjiLMOr4Y3zh9OlwuFxa+9VbdYzabDYveew8jhw/X5QhiQN+vaW1tYaPH3G4Hjh17FyaTFfHx/QREJb8IHY6TMBqNiI+P9zuaSrA7duxAYWEhLrroIpjNZpjNZqxbtw7//Oc/YTab4Qqig3rBggXo2rUr5s2bhwcffBALFy7Exx9/jK5du+L48eP43e9+h6eeeirg80mWFuPipDqTeh0//iE8HmfYlIetVsAcYQDc+mzBjhwxAjddfz0efeIJFBYVoUe3bnhn8WIcz8vDm6+9Jjo82cTFq6ieKLFt2+6Bw1GO1NQJiI7uiJqaAuTlLUZ5+QEMGfIPRETEig5RFmq6/irdzX3ppZfi559/9nts1qxZ6NOnDx5++OGg+kxfeuklPPTQQ5gzZ05dMp8+fTqmT58eUmySJdh27aQ6k3odO7YYUVFp6NBBuk50NUtMFB2B/N594w08/tRTfmsRf/Xpp5gwbpzo0GSj59e1c+cZOHLkTRw+/BpstvOIiIhDYuJQDBq0AJ066bdbRy2vqZQl4kDFxcUhOzvb77GYmBgkJyc3erw1x44dg1XCff84wQbhiis2iw5BUe3aQV2jJ2QQFRWFF+bPxwvz54sORTHtEvX7mnbpcgu6dLlFdBiKU9P1V8sjmmtra/HYY48hNzcXY8aMwUMPPQSj0Yj8/HxERUUhKSkpqPNJlmCjoujQ6dTBsBQOCTYc6TnBhiu1tGDV4ocffgjp+2bPno2dO3diypQpePHFF+FwOPD4449j6dKl2L59O5YsWRLU+SQde6amuyjWdpxg9SkqivrXmX6oJcF6PNIdIqxZswYffPABXn/9dbzyyiv4+OOPAQBTpkzB+vXrgz6fpAk2JUXKszHRkpPBCVZvLuzXyZ9VfUlW0Zo3brc0hwjR0dFod6GlmJ2djdOnTwOgft6SEBZ8ljTBduki5dmYaF27Qj0T7Jg0LryeXbuKDYNJi19Padx999146aWX4PF4EBMTA/uFld6+/vprdO/ePejzSTp7lV9k/TAYgM6dUdfiCYv19cLBhYpEVhawYYPgWJgkYmOBtDTRURCR5V0pnDhxAp999hnWrVuHXr16wW63Y9q0afj222/x7rvvBn0+SRNsVpaUZ2MiZWQAdXO6jUYVrSbO2uRCC5Y/q/qhttdSy6OIy8rKMGnSpLp/X3fddejcuTOefPJJDLuwjWUwJE2waWlATAxQVSXlWZkIfh9a7ofVjwsJtksX+quWL4aMqC3BalnD3XTaSvIONu6H1Qe/cj/3w+qDt9wPGkmckSE4HiYJNSVY70ITWh3k1Jzy8vKAN2OvT/IVhPv1A/bvl/qsTGl9+9b7BydYfWjwOvbrB5w6JSgWJgmjEejTR3QU/rTcB5ubm4u///3vOH78eN0AJ4C2qdu8eTOOHz8OAFi7dm1A55M8wQ4eDHzyidRnZUpKSQEyM+s94N1EWW23lSw4DdZkHTIE+O47QbEwSfToASQkiI5CP+688064XC6MHDnSbw3j6upqbNmyBUOGDAnqfJIn2M6daU7W+fNSn5kppcn3kMnECVbrmmjB8upr2nbRRaIj8CdiLWIp7dq1C/v370eXBn2dRUVFWLhwIV588cWgzidL7S/IJM9UpskPLZeJtc1obDRYLSICGDhQUDxMEmpLsIC2V3Kqra1FbGzjHZc8Hg8MIQz2lOWqqcYXnQXGagV6927iP5q4QDMNaWbLrqFDFY6DSaZ9e0BtWxZrfZDTsWPHkNzEslipqak4duxY0OeTZZv0Pn14uo5WDR4MmJt7V5hMgNOpZDhMKs0k2CFD6PXml1V7hg8XHYH+dO7cGWfOnMG///1v7Ny5E7GxsRg0aBDmzp2Lzp07B30+WVqwZjMwfrwcZ2Zyu+SSFv6z2czLVK2F6kNsLDBihMLxsDYzGFr5rAqk5RbskSNHMGTIECxbtgwxMTH44osvsHHjRvTq1Qt79+4N+nyydazVWwyDaUTHjq0M+feOJmba0sqN0ZQpCsXBJNO/P5CeLjqKxrS+m87DDz+MCRMmYO/evXj++edhsViwYsUK3H333XjooYeCPp9sV8sOHYAgN5Nngl16aQBfxK1YbQngpqh37wvrTjPN4Jsieaxdu7Zuk3VPvSx/++23Y0MIi3fL2hwJ6ILNVCEqChg3LoAv5MFO2mIyBfR6TZ6sQCxMEklJ6h6cpuUSsc1mQ1JSUqPHq6urERMTE/T5ZG2ODBnCc2JD4XIBNTWAzUaDTxwO/z/dbv8yincFPLOZjogIOrx/t1oBi6Xl6+zYsZRkW+V9IodDkp+VySzAisPYscDSpUB1dfNf4/H43oMuF70PXS7f370XxYbvS6ORDpPJ96fJ5HuPsuBceql6e2q0vptOly5dkJubi27dutU9durUKTz88MOYOnVq0OeT9e1tNALXXAMsWiTns2ibx0MXtepqSqrexBrsOQC60DX3vSYTJVrvERNDFziALnJXXRXEE3pHE2v5kxQOzOaAqw1WK3Dllf6rsDkcgN3u+zPYkcbei21LrRGDwXdDaLHQ0cyAZwYalHbZZaKj0K/LL78cH374IS678Euurq5G586dMWnSJLz00ktBn0/2+8eJE4EVK4CCArmfSTtcLqCiAigvpz+V2AnO5QIqK+nwslqB+Hi6sKakBHEybsVqQ5DNw8mTgc8/B86do9WdlCjTeTyUvO1237Q+s5mqKVar7yaQkWnTgOho0VG0TMsrOf3jH/+o63tNT0/HN998g+7du6NHjx4hnU/2BGs0AjfeCPzrX3I/k7q53UBpKR1VVepo/Hlby2vWAHv3AiNHAlOnBjjghVux6hZg69Xlos05du8GDh+mb2upTKwEp9N3M2g0UrKtX3EJV0lJwOWXi46iZVpfKhFA3YpNVqu1riUbKkV6QEaMoC2VQlgIQ/NsNuqDLilR557lCQmUK8+dA77+mo5+/eiDPHp0C40gbsWql/e1aUFZGbBtG7BjB1VRvDp0AE6fDr6bQi5ut68LJSKCEq3VGp7j7G64gW8ytEaxIQY33wwsWKDUs4lXUQEUFfmXZNXGZKIScUP799PRrh2VDa+5BoiLa+YE3IpVnxZar3l5wI8/AgcONN3SMBppT+dDh2SOMQQOB1WAysupTBoTEz79tenp1N2mBXw58FEswfbvTy2izZuVekYxqqqov1kLy0QmJ7c8GrG0lAa9fP01cN111P/jN9LYYKBRKWpp7jDfMN0GCgqAVauAgwdbP0VqKnD2LLVy1cjt9pWQY2PpUOuoWikYDMBvfqONn1EPJWIpKTpI/rbbqGWk1g9uW9TW0kWsvFx0JIGJiaEjEDU1wJIlwDffADfdRP20dRVIo5EXs1WTiAi/1mtJCfWx794deMvCYAB69gRyctTZrVFfZSXdzMbF0ftZj6XjKVOAvn1FRxE4bsH6KJpgY2OBO+8EXnlFyWeVl8sFnDkDFBeLjiRwRiO1XoNVWgq8/jrw5ZfA3XfX25bQbKZfBH+yxDKb65o5Ticl1k2bQkuSUVFA167AkSPShigHj4dubCsraUyB1So6IumkpQG33CI6ivBz7tw57Nq1C+fOnYPVakWXLl0wcOBAGIMsIyg+zXvoUP2UiisqgFOntDfOJyWlbX1XBQXAU09R/+ysWUB0NJeKhfNWEgCcOAEsW0YD19qiQwc6h1YqTm43tdhramj8gBZKqi0xGIB77glwARiV0HKJuLa2Fm+//TbeeOMN5OTkAACio6Nhs9ngcrkQHx+PG2+8EXPnzsWgQYMCOqeQt+BttwGJiSKeWRouFyXWY8e0l1yDKQ23ZvVq4L77qJRY/wLPBIiIgNNlwMqVVGVoa3IFfKVirQ0kqq0FCgsp0WrZZZdpqzTspcWlEtevX48+ffrg3XffxV133YWcnBzYbDZUVFTAbrejoKAAS5YsQUREBCZPnozbb789oPMKSbCxsXRh1uL1uLKSRlhqqSTsZbEEuaBEAM6fp9bsa68BdrdZ+80GLbJYcOasEf/6F7Bxo7SV+qgo2gxAa7yt2eJibfZc9O0L/OpXoqMIHxUVFfjwww+xadMm/P73v8fAgQNhrpegUlNTccUVV+A///kP8vLy0K9fv4DOK+xq2L07MHu2qGcPzfnz2my1ApT32reXL/999x3w2OMGFFe2sugxk5bZjL2/mLBwoTSt1qYkJVF/rBbV1tJ0OS2NwUtNBR54QJsNEECb29VdddVVGDlyZEBfGx0djUceeSSgrxXa3Bg7lpbpUzuPhybfnz6tzbthgJKr3B/Y3FzgTw8ZkHvCIu8TMQCAx2jC6nVmfPih/Dd9nTrRhV+LnE5KsloYIhAVBcyb18y8cw3w9sFqrUQsF+H3SDffTP2Ze/aIjqRpTidNztfCvNbmJCcrN1CiuBj482NGzPmdBRNH2ZV50jBkdxjwyZcR2P+LctWCnj2pX1PNi6c0x+OhClR8PHVRqZHBANx7Ly30wcSYNGmS3z6wzVm7dm1A5xOeYI1GYO5c4G9/A44eFR2NP7udYrJrOE8kJDS9WpOcHA7g5X+aUHjWgpuu1fAvT6Wqagx4+4NInDmjbCneaKRlNPfsodKrFpWX0yDFhATRkTT261/TsrJap9UqHwAMHjzY799lZWV4//33MWfOnJDOZ/AEkq4VUFlJSfbECdGREJuNkqsW+1u94uNDm+8qpRuvc2HmTZxkpVJRZcCixZEoLBLXz22zUZLVQsm1OdHRNJVHLW6+GZg+XXQUbXfxxdfgn/9cLsm5HnvsGixfLs25QnX06FEMGjQIFfUX7A6CaoZ8xsYCDz8c4E4uMuPkKp1PPjPhnaXcJyuFiioD3nxPbHIFgMhIYMAAbc3PbKi6mkYZq8GNN+ojubLGVJNgAerYf+QR2nlHFG9ZWMvJNSFBHcnV6/PlJnywjJNsW1TVUMv13Hl1jNCOitJ+kq2podXJRLr1VuD668XGICUe5ORPVQkWoJbsI48AAwcq/9xOp/aTa2IiTatQm48+MWH5t5xkQ2F3GvDOB+Jbrg1FRtLnVKsjXgFqyYpYP9xsBn77W9pAQ2+0OE1HLsIHOTXFaqWh6kuXAitXKvOcHg+NFtbqgCajkaZRREeLjqR577xnQmZmJIb0t+vnEyQzj9GET7+KQL7CA5oCZbFQS/bwYVo9SYsqKynhKfXZiY+nea59+ijzfErS8lKJAPDOO+/4/buwsBBOpxNvv/123UbsAHDHHXcEdD7VDHJqzsaNwFtvyT9R/PRpGsavRWYzzXO1aKCBGBMDPL/Ag4wUu7Y/iUowm7F2YwTWrBEdSGBOn6aFWLQqNVX+Dc27dKHGg1bnFLdmwoRr8NJL0gxM+utflR/klBRA+c/j8aAkwA58VbZg6xs3jhYdf+UV+RYdP39eu8nVaqUPq1bWi62qAp6db8DzCyyIsTjUvx+aKBYL9h804fvvRQcSuI4dqRV44IA2X9bz52n3GrlWOxs5UnuL94dC3U22lhVLvAau6vpgm9KjB/Dcc/QGlVplJZCfL/155WYwUF9r+/baSa5e+fnAP140wG22yN9k0BqjEYiMxNlzJnzyifYuVomJwEUXaXMzD7dbnhvt6Gjqb73/fv0nV0Dbg5zy8vJQK+Ekb00kWIAGP82ZA/zhD9ItnOByASdPau8iFhlJrYWEBO0u+5uTA3z9Nai+HRXFmwQAdLNhscDlMeLjj7U7HiAyEujfn26MtXbz53BIO+hp0CDg+eeBSy6R7pxMPt26dcOQIUNw+PBhv8fPnz+PrBCmt2juqjZ8OC1IIUVr9swZbY0Y9rZa09P10fBbvJheAxgMdFXWww8VigutVpjNgMGAH36gPXe1rkMHbbZmKyvbfl3wtlofflido/rloodpOpmZmRg1apTfcogulwt5eXlBn0tzCRbwtWb/+MfQF6aoqNDWlnMxMdpvtTZkswGvvlrvw+RtzWqt2RMqg6Gu1eptwefnA+vWCY5LQt7WbJ8+2iqPhroIhckEXHppeLdatT5N591338UDDzyAK664AgsXLmzTuVQ/yKklAwfSFIEtW4BPPw18moB3w3QtsFrpDlgLI4RD8csvVCqumw9oMNAP63bT0HEtjpYJREQEXY3r3S25XMCyZfocXJ2SQoufFBRQt4zay99OJ5WKA+2OMhhoHeGbb6YKE9Mug8GAxx57DAMGDMBtt92Gffv24ZFHHvGbphMoTSdYgN7Yo0dT6fiHH4Dly1tfnUULpeHISEqsWrrrD9XixXRxat++3oNGoy/ROhz6yTpmc10puKF16/RRGm6OwUDJJy2NWuqnT6t7n9bKSrrBba3nYsAASqzduysTl5ppfR5s/Vmr1157LTZv3oxp06Zh27ZtAe2y05DmE6yX2QxMngxcfDGwYwewejVw8GDjr6utVW9p2GCgUnB8PCXYcGGzUZKdN6+J//T2T7rd1MRT8xW5OQYDvUEbtFjrq6gANmxQOC5BTCYgM5O6PIqK6IZXrVvglZVR67uhqChg/HhgyhTaK5f5aG3QaH0NW6n9+/fH9u3bccMNN4RnC7Yhs5kGQI0cSWXg77+nxSq8I6/V2EKIiKDl5mJjw6f7saGNG4HrrmthHWqjkQ6z2Zdo1f5JNpko3gBGSK9dq/6qitSMRqpatG9PNxgFBZRw1dQCstvpBtB7w5uZSUl17Fhq3TJ9cTXRJZWUlBTw/q8N6S7B1tepE3D77cAttwD79gHffkt/qoHFQiMNo6PDq7XaHI8HeO894IknWvlCb2vQbPa1akUPO6zPZKLM0UJrtaHz54Ht22WOS+Xi4ujo1o0GGJ0/T3+qoWBhMgE33QQMHaqO3b7UTKsl4vPnzyM5iB1SAv16TY4iDpbFAgwZQmWozp2BjAzaCzIqSrkRuSYTJdPkZF95LDGRk2t9OTnA3r1BfIPRSM3/yEh6MZsYOCQ7b8K3WCgGi6XZPtbmrF6tzYuSHEwmKsn27k1VqAED6LMSG6vcy2qx0Oe0Rw8aG9CrF/WvcnINjBan6SxatAijR4/GBx98gJqamma/bv/+/XjooYfQr1+/gM6r6xZsfTt3+lqvkZG+xObxUGnOWwqy232DV0OpQNZvYHmfx3vNZa177z1gwYIQvtH7i/eqPyHP+/e2lJQNBt/hLVd7/90GZ84EeVMRRgwGmpaWkED/drtp95vKSjqqqnyf2VCYTPTZtFopgXuPpkbsr14NZGfzeiitET3FJlR//OMfkZmZib/+9a/4zW9+g6FDhyI7OxtJSUmoqalBfn4+tm7divz8fMycORM5OTkBnTdsLvtfftn0495ZIRYLfbjqc7l83X3e63P9N4/3+urtavNWB1noDh2iwWm9e7fxRN4X5kKntttNF+XSEg/KSj0oLfWgrMyA2lqP382U91tiYw1IaAe0a2dAQgLQLtGAKBmqDZs2afOCJILR6EuC9dW/Sbbb6e/151PW/5x6P+sWS3DjHYqLaUpZ//7S/kxMPWbMmIEZM2Zg06ZN+Pbbb5GTk4OcnBxER0ejS5cueOyxx3DdddehXbt2AZ8zLBLsmTPA7t3Bf5/3YqvXOahqtWJF2xKszUYD3I4fpy0I8/KAs2e9ZSfDhSN4Viv163ftSruidOlCU05CbcRWVwM//xza9zKf+jfJctq6lRNsILTe3TFmzBiMGTNGknOFRYJduZJbCVqyaRMwe3bgG3m73bRN2u7dlLDy8+V5vWtqgNxcOryioqivbtAgWvgkmGUBd+5UxyAeFpijR4Fz55qetsOIVkvEctF9grXZoKktvxiV+Favpmk7LX3N3r2+pFpRoVx89dXWUhx799Jc3s6dKdFedFHL8yM9HmDbNuXiZG3n8VAr9sorRUfCtEL3CXbjRvVOYmfNW7kSuPbaxn3aRUW04tGPP9IgF7U5cYKOr76iEvLFF9NI1IarAR0+rN09iMPZzp20oA13GzVP6yViKek+wa5fLzoCForCQhrw1KcPfWB//pmWwty/XzslqLw84J13gI8/poUJJk6kPlsgtDEBTLzaWnpfZmeLjkSduETsT9cJtrpaPQtLsOBt3Uqt1M8/p0FKWlVdDaxaRceIEbSxwaFDoqNioTpwgBMsC4yuE+zOnfrdjEXvamtpTmwIexyr2tatdJjNNL8zXJfG1LJDh6iqwlPymsYlYh9dJ1geRKI9djstkeddOzo9XX87CjkcNCK5spI2doiP54u1llRXUz97166iI1EfrS6VKBfdfqxdLmrBMm3weGibwTNnfMkVoN1M9MZbVfF46Odr+DMz9TtwQHQETAt0m2APHeLRw1pht1OSaSqZ6i3BNrVio9NJfczFxXz3rxXch968+qtoteXQA92WiOsvBsDUyduCaymJqnEqTlu0lEArKqh0nJysv7K43hQV+W9jxwiXiP3ptgV75IjoCFhLXC5qtbXWQnW59FU+be3O3NuaLS9XJh4WGo+Hqi6sMW7B+nCCZYrzloRttsC+vrpa3niUFOjdfUkJLcunlwuNHp0+LToCpna6LBHX1PDdpVpVVdEKRsEkjupqIClJvpiUFEz5rKqKRhynpfF0HjXKzxcdgfpwidifLhPs0aP8IqtRaWlog5b00g8bynvS29pPS+Pl+dSGW7BN42uvjy5LxPzGV5/i4tBHBOulDzbUcq+3vzrQkjpTxvnznExYy3TZgi0uFh2BvCorc/HLL4/j/PmNcDiKYbV2RqdOv0KPHn+E2RwtOrxGzp9v25Qp7wbaoe67qhZt6U91uynJpqWpc4Rxfv427NnzDvLy1qKs7Dis1mR07DgKEyc+g+TkXqLDk4XHQ9WVQLdVDAd6GqAkBV0m2JIS0RHIp7r6JNatGwGzOQHdus2FxZKE4uLNOHDgSZSW7sCoUV+IDtFPcbE085GdzsY70mhNWy88Hg9tgtC+vfqmh2zevAAnT/6Ivn1vQlraQFRVFWD79n/hzTcvwp13bkFamj4X762o4ATbELfqfTjBaszJk+/B4SjF+PEbER/fHwDQtevd8HjcOHnyXdjtJbBYgtj1W0YlJdLt0+pwcIL1nsObZNXUJzty5DxMn74EJpMvqH79ZmDhwgHYvPlvuPba9wVGJx9R+xAzbdBlH6yeE6zTSRMkIyPb+z0eFZUOwAijUR1X3YoKaedy2u3SnUsUqUpnbjclWTVtZNGp0xi/5AoASUk9kZraH+fO/SIoKvlxgm2M58H6cILVmJSUiwEAOTmzUVq6C9XVJ3Hq1Ic4duw1dO9+H8zmGLEBggYlSd0P7nBIez6tc7koyar5QuTxeFBVdRbR0SmiQ5ENJ1h/3mk6Uhx6oMsScU2N6Ajk07795ejb92kcOjQfBQXL6x7v1evP6NfvGYGREaeTlpGTmh4+cFInQ7udBpClqDR/7d27GBUVpzFhwlOiQ5ENj+xmLdFlglVT6UwO0dFdkZw8ARkZN8BiSUZBwdc4dGg+oqI6oFu3ucLi8pYu5UiGam6piVRVRX2x8fGiI/F37twBfPvtHHTsOBoDB94hOhzZ8PvSHy804U+XCVbPL/CpU0uxa9fdmDz5EKzWTgCAjIzrAbixb9/D6NTpVlgsyUJiKy6Wr5TLF7LmlZTQqGK1jCyurCzAhx9ehcjIBNxwwycwGvW7DJWerzWh4s+qjy77YPXs2LH/ICFhSF1y9erQ4Rq4XNUoLc0REldNjbwrLml9Dqzc1LJucW1tGZYuvQI2WyluuWUl4uIyRIckK35f+uM+WH+6TLB6XrfVZjsLj6dxDdzjcVz406l0SHC7qS9QTnwha5nTKX5wn9NZi48+mobi4kO4+eavkJraT2xACjDq8grKpKLLt4fW50u2JCamF8rKclBZ6b/j86lTHwAwIj5+oOIxFRfL3+/NCbZ1FRXiBt243S4sWzYDp09vxvXXf4xOnUaLCURhnGAb42k6Prrsg42L0+/w+Z49/4TCwhXYsGE8srLmwmJJxtmzX+Hs2RXo0uU3sFqVLcnJXRr2MuvgnWowyH/hOHcOyMhQ/oZk9er/h9zc5ejZcxpqaorx88/+C0sMGPBrZQNSSIz4WXGqo5fyrhR0cNlqLDFRv1tJpaRMwIQJm3DgwF9w7Nh/YLefR0xMFvr2fRY9ez6kaCwej3LrPuuhKqFE0nM6aYGPhAT5n6u+s2d3AQByc79Ebu6Xjf5frwmWl0lkLdFlgtXL3qHNSUwcgdGjvxEdBioq6IKuBE6wgSsrA2JjlR2LcNttPyj3ZCrCCdafqGk6zz33HJYtW4YDBw7AarVizJgxWLBgAXr37q18MPXosgchUR1L8eqa2x369nOh4AQbOI9H2dcmnHGCbUxEH+y6deswZ84cbNmyBatWrYLD4cDUqVNRJXgzaW7BspCUlyt3p2o06ntkuBwqK2nxCT30XasZJ1h1WLlypd+/3377baSlpWHHjh2YMGGCoKh0mmDVunScXrhc0i7k3xo17RrTFkoOPPJ4gNJS/izIyWpVz+IeaiFlidjtdqO8wYUmMjISkQH80ssulHCSBLe2dFki7tZNdAT6VlGh7DD6aPXtIR8Spad0VFUp10cejtLTRUegTlKViHNzc5GQkOB3PPfcc60+v9vtxgMPPICxY8ciO1vsPsS6bMF26EAX5epq0ZHoj8cjzQbqwdDLVAiDQZmpOvVVVgLt2in3fOEkQ9+LVAnXs2dPbNu2ze+xQFqvc+bMwd69e7Fx40a5QguYLhOswUCt2L17RUeiP9XVym+moJcWLECtWCV/f5WVNGWHF+qQHifYxqQsERuNRsQHuYvF3Llz8dVXX2H9+vXo1KlT698gM12WiAGgRw/REeiTiAU89JZgleRycSVHLh07io5AfUStRezxeDB37lx89tln+P7775GVlSXPDxgkXbZgAe6HlYPDofxSfFFR+hpBLKIlWVGhnzK7WkRFAcliNq1SPRHLHM6ZMwdLlizBF198gbi4OBQUFAAAEhISYLValQ/oAt22YPv357KY1JTuewVowQQ9EbF2rc0m3zaC4aprV9ERsPpee+01lJWV4eKLL0Z6enrd8eGHHwqNS7ct2KQkoHt34PBh0ZHoh4hSo94G6BgMlGSVXu2mulr55RP1rE8f0RGol4iVnDwq3R1Aty1YABg+XHQE+uFwKD/lw2ikxRL0RkTJu6ZG+efUK4MBELwCn2pJNUVHpfkyaJxgWUBEtF7j4/W5HZiIBGuzKT/6W686duQVnFhgdHj58snK4pVspCKiBaS38rCXt0ysNG7FSoPLwy0TMYpYrXSdYAFg5EjREWifyyVmI2899xlygtWufv1ER6BeoqbpqJXuE+yUKaIj0D4RyTUxUR876DRHxCL8tbXKP6fedO4MpKWJjoJphe4TbJcufMfZVna78s+Zmqr8cyrJYFC+L9bt5rWJ24orYq3jQU4+uk+wAHD55aIj0DYRi0vocfRwQyIGO4m4WdKLmBiaX8+axyVif2GRYEeP1nd/ntyUvijrvfXqZTIpvxgKJ9jQDR3K++uy4IRFgjWbuS82VE6nsneTRmN4jfxW+oLNCTY0BgNP+wsUl4h9wiLBAsC0abRBMguO0hfk9u31tfZwa5RuxXKCDc2QITTwjrWMS8T+wibBxscD06eLjkJ7lFycwGSiBBtODAZlW7G82ETwzGbg0ktFR6EdnGB9wqpH4ZprgG++AcrKREeiHUpekNPTlU02Dkcl9ux5AYWFP6GoaCtsthJMnLgIvXrdqVwQoBsLp1O5spjTyX2JwRg5ksdwsNCETQsWoNGpN98sOgptUSrBRkQoP7+wtvYcdu58CqWlvyApaZCyT16PwaDsnF9uxQYuMhKYOFF0FNrBaxH7C6sECwBTpwIdOoiOQjuUuhh37Kj86kbR0emYOfMMbr01DyNHvqDskzdgMin383OCDdz48UB0tOgotIVLxD5hl2DNZuDuu0VHoR1KLEwQGytm82qTKRLR0eq521KqFcsJNjApKcC4caKjYFoWdgkWoBGBPGghMHLfSRoMtHm10vNB1choVKZvVC+tAzkZDMANN3BfdbC4ROwvLBMsANx1l5hWk9bI/Ubv1In6xhkxm+W/2dDLxUtOY8cCmZmio9AmLhH7hG2CjY4G5swRHUV4i43lhdMbMhgAi0V0FOEtJQWYPFl0FEwPwjbBAlQqnjpVdBThyWjk0nBzlCoVs8aMRuD66/n3HyouEfsL6wQLALNnAz17io4i/GRlcWm4JWazmD1jw92VV9KWdCx0XCL2CfuPsMUCPPwwL4PWHDlamBkZ/PtujbdULMfvn6sGTRs+HBg1SnQUTE/CPsECNNjp0Uf1vcF3qKRuRSUm0opNrHVy9cdygm2sa1fg6qtFR6F9vBaxP+5puKBnT+D3vwdeeUV0JOpiMgEOhzTnslrV1++6b9+/YLOVoro6HwCQl/clKitPAQCys/8Ai0XsGnlGIyVZKRfpD6fNFAKRmAjceiv/XqSil/5TKXCCrefii4GzZ4GlS0VHoh5SXXQsFrqJUdtFbM+ev6OyMq/u38ePL8Px48sAAD17/lp4ggXodxYRId2NjtpeA5Gio4HbbqPN1FnbeVuwjHCCbWDGDGotLFsmOhJ1kOJiHBEB9O6tzuknt956XHQIAfGOapUiyfIIWWK1AnfeyVPFmHz4o9aE226j5eS++EJ0JOK1NcF6k2tkpDTxhDOpkiy3YCm53nEHDbhj0uISsQ8n2GbceSclh08+ER2JWG25GFssnFyl1tYkazSqqw9chOhoYNYsHmwnBy4R++ME24KZM4G4OOCdd8L3TRPqyGqrlfpc1VgW1rq2JNlwHymfmEgVKi4LMyVwgm3FNdfQern/+AdQXS06GuVFRFCLJ5iyT2IijRbmUqR8vAtR2O3BvTbhfMPTrRtwyy28/ZzcwrUx0hSeBxuAiy4Cnn8+PEtKwc7FzMigCxknV/kZjVR+D2aucrgm2JEjqduHk6v8eKlEH06wAerYEXjhBVq/ONwEclE2GoHu3SnBhnsfn5K8N0CB3tCEW3+40Qhcey0wbRovPcmUxyXiIMTEAI89Bnz1FbB4sbST/9WstQQbG0slYV5bWAxvknU6W+6XNRjCqw+2Qwfa0zUcK0+i8CAnf5xgg2Q0Ur/ssGHAq68CBw6Ijkh+zbV6jEZq2aelcatVDcxmasna7U1f5MKlPGw0AhMn0sIx3FWhPL2Ud6XACTZEGRnAs8+GR2s2IoIu3k6n7zFutaqTwUA3RE21Zq1WMTEpiVutTE04wbaBtzU7YgSwZAmwcaN+796sVqCigpJtx460QQK3WtXL25p1OGjRFEDfA3xiYqjVOnIkt1pF4hKxP06wEujQAZg3D5g+HXj/fSAnR3RE0ktJARISqBzMg0W0wds363bTnxaL/m4ALRZg3Dhg7NjwG8ClRpxg/XGClVC3bsATTwB79wLvvQccOiQ6oraLiqJtvKZNAx5/HKipER0RC5bRSP2RY8YAq1YBR46IjqjtzGYaB3HxxdRdwdRDbzdxbcEJVgbZ2cCCBcDBg8CKFcCmTdLthKKUzEzg8svpAuYtLQ4YAGzdKjQsFqLBg2nBlFmzgIIC4KefgN27tTd2IDGRNkYfOpR3wGHqxwlWRr1703HXXcCaNcDKlUBhoeiommc0Uh/WFVdQMm1o1ChOsFqUnAz06OH7d4cONDf08supO2PrVnW/Lw0GWnZz5Ej6k7so1ItLxP44wSogPh647jq6qB06RBe0bduAU6dER0Yl4EGDqFUwbBj1szanf3/qiz13Trn4WNtNmNB0UoqMpJumUaOA/HyacvbLL8CZM8rH2JDZDGRlAX360NHS+5KpC5eIfTjBKsho9F0wbr+dLmTbtgE7dwKHDwNVVcrEkJEB9OtHo58HDAh8fqTBQBdr3itXO8xmGgTUmowMOiZNAsrKKNkeOgScPKncGtxJSUCXLvT56NGDBy0x7eMEK1B6Ok3zueYauusrKKABKN7j9GmgtDT0kktUFJCaSoOvunWjpQy7dWvbfMhx44Dly/3nxDL1GjqUdoQKRkIClWNHjqR/l5bSezE/n47CQpqyFer70mKhqk56ui+xZ2SExzzdcMAlYh9OsCphMNAFJz3dv8XhdlOLoqTEd9TU0NxGl4tapCYTtVTi4qgVkJREg0HkWAQiNpZKyVu2SH9uJr2LL277Odq1o6N/f99jHg+1bCsqgPJy+tNmo/er933pPaKjKaHGxtJ7lBcn0S/ug/XHCVbljEZKlomJoiPxmTKFE6wWZGVR1UIOBgON4o2JoUFTjLHGeDweC1pmJrVimbrdcIPoCFg44u3qfDjBspBMn85L0qlZ//5Ar16io2DhxlsiluLQA06wLCRpacD48aKjYM25/nrRETDGOMGykF19dfhsgaYlI0ZQGZ8xEbhE7MMJloUsPp5WfWLqYbFQ+Z4xEbhE7I8TLGuTyy/n1pKaXH89rbbFmCicYH04wbI2MZloAXke8CRer17AJZeIjoIx5sUJlrVZp07AVVeJjiK8WSzAnXfS/FTGRJGq/5X7YBmr54oruFQsEpeGmVpwidiHEyyThMkE/Pa3vJ6sCIMGcWmYMTXiBMsk06EDJVkuUyonIwOYPZt/50wduETsjxMsk1R2Nu19y+QXEwPMncuL5zN14RKxDydYJrnLL/dtdcbkYTQC99zD/a6MqRnvpsNkcfvtQFERcPSo6Ej06dZbaWNyxtSEt6vzxy1YJouICOC++4DOnUVHoj/XXw9MnCg6Csaaxn2wPpxgmWyio4EHHgA6dhQdiX5ccw2V4Blj6scJlskqNhb4f/+PW7JSuO462mCBMbXitYj9cYJlsouNBebNA7p1Ex2Jdt10E2+swLSBS8Q+nGCZIqKjqSU7erToSLQlMhKYMweYMkV0JIy1jluw/ngUMVNMRARtDNCpE/DJJ/q5S5VLaiol14wM0ZEwxkLBCZYpbsoUID0deP11oKZGdDTq1Ls3cO+9tJgEY1oiVevTqIP6qg5+BKZF2dnA//0f0KWL6EjUxWAALruMRl9zcmVaw0sl+uMWLBOmfXvg0UeBlSuBL78EXC7REYnVoQNtOceDwRjTB06wTCijEbjySmDwYGDRIiAvT3REyjMYqGx+7bXUT82YlullgJIUOMEyVcjIoNbsd98BX38N2GyiI1JGZiYwcya3Wpk+6Km8KwVOsEw1jEZapWjsWOCbb4B16wCnU3RU8khNBaZPB4YN463mGNMrTrBMdeLigBkzgMmTgeXLgS1b9HNXHB9PqzGNGweY+dPHdIhLxD78EWeqlZxM82YvuwxYswb46SfAbhcdVWg6dKAF+seNo8UjGNMj3k3HHydYpnoZGcBttwE33ghs3gz88ANQUCA6qtYZjcCgQcDFFwN9+4qOhjGmNE6wTDOsVmDSJDoOHKDS8c8/AxUVoiPz16ULjYoeMwZITBQdDWPK0kt3jhQ4wTJN6tOHDrcbOHYM2LMH2LULOHNG+VjMZopl8GBg4ECgXTvlY2BMDbhE7I8TLNM0oxHo3p2O664Dzp8Hjh+nIy8POHECqK6W9jnT0qiV6j26duV+Vca8uAXrwwmW6UpyMh1Dh/oeO3cOyM8HysroKC31/b22lu64XS6aLmMy0REbCyQk0NGuHf2ZmEjzVq1WUT8dY0xLOMEy3UtJoYMxJi8uEfvjBMsYY0wyXCL24d10GGOMMRlwC5YxxphkuETswwmWMcaYJLgP1h+XiBljjGnev//9b3Tt2hVRUVEYOXIktm7dKjokTrCMMcak492yrq1HMD788EPMmzcPTz75JHbu3IlBgwbhsssuQ2FhoTw/ZIA4wTLGGJOEt0QsxRGMF198Eb/97W8xa9Ys9OvXD//9738RHR2Nt956S54fNECcYBljjKmO2+1GeXm532Gz2Rp9nd1ux44dOzB58uS6x4xGIyZPnozNmzcrGXIjPMiJMcaYJKZNS0BZ2TWSnCsv7yQSEhL8HnvyySfxl7/8xe+xc+fOweVyoX379n6Pt2/fHgcOHJAkllBxgmWMMSaJ9957T7Jz2Wy2Ri3WSI0t+s0JljHGmOpERkYGlFBTUlJgMplw9uxZv8fPnj2LDh06yBVeQLgPljHGmGZZLBYMHToUa9asqXvM7XZjzZo1GD16tMDIuAXLGGNM4+bNm4c77rgDw4YNw4gRI/Dyyy+jqqoKs2bNEhoXJ1jGGGOaNmPGDBQVFeGJJ55AQUEBBg8ejJUrVzYa+KQ0g8fDex8wxhhjUuM+WMYYY0wGnGAZY4wxGXCCZYwxxmTACZYxxhiTASdYxhhjTAacYBljjDEZcIJljDHGZMAJljHGGJMBJ1jGGGNMBpxgGWOMMRlwgmWMMcZk8P8Bqjv6I+btFisAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -3596,8 +3775,8 @@ "\n", "# Set the array for the colormap with normalized firing rates\n", "p.set_array(firing_rate_position)\n", - "p.set_clim([0, 8])\n", - "p.set_norm(Normalize(vmin=0, vmax=8))\n", + "p.set_clim([0, 10])\n", + "p.set_norm(Normalize(vmin=0, vmax=10))\n", "\n", "# Add the patch collection to the axis\n", "ax.add_collection(p)\n", @@ -3611,7 +3790,7 @@ "# Create a colorbar\n", "cbar = plt.colorbar(p, ax=ax)\n", "cbar.set_label('ΔFiring Rate (Hz)', rotation=270, labelpad=15)\n", - "cbar.set_ticks([0, 2, 4, 6, 8])\n", + "\n", "# Show the plot\n", "plt.show()" ] @@ -3627,7 +3806,7 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -3637,7 +3816,7 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -3677,7 +3856,7 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -3716,7 +3895,7 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -3726,12 +3905,12 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -3754,7 +3933,7 @@ "plt.xlabel('Time(ms)')\n", "plt.ylabel('Rate(Hz)')\n", "plt.xlim(0, 400)\n", - "plt.ylim(-1, 20)\n", + "plt.ylim(-5, 35)\n", "plt.xticks(np.arange(0, 400, 200))\n", "plt.title('IC trials', color = 'g')\n", "\n", @@ -3767,7 +3946,7 @@ "plt.plot(psthtli, RE_mean, color = 'b')\n", "plt.fill_between(psthtli, (RE_mean-SEM_RE), (RE_mean + SEM_RE), color = 'b', alpha = 0.2)\n", "plt.xlim(0, 400)\n", - "plt.ylim(-1, 20)\n", + "plt.ylim(-5, 35)\n", "plt.xticks(np.arange(0, 400, 200))\n", "\n", "plt.title('RE trials', color = 'b')\n", @@ -3779,12 +3958,12 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -3807,34 +3986,32 @@ "sorted_IC_heat = IC_heat[sorted_indices, :]\n", "sorted_RE_heat = RE_heat[sorted_indices, :] #in same order with IC heat\n", "\n", - "\n", "fig, axes = plt.subplots(ncols=2, figsize=(10, 5))\n", "\n", - "psth = axes[0].imshow(sorted_IC_heat, cmap='bwr', vmin=-50, vmax=50, aspect='auto', interpolation='nearest')\n", + "psth = axes[0].imshow(sorted_IC_heat, cmap='bwr', vmin=-30, vmax=30, aspect='auto', interpolation='nearest')\n", "fig.colorbar(psth, ax=axes[0], label='ΔRate (Hz)')\n", - "axes[0].set_title('PSTH per Neuron')\n", + "axes[0].set_title('PSTH per Neuron (IC)')\n", "axes[0].set_xlabel('Time (s)')\n", "axes[0].set_ylabel('Neurons')\n", - "axes[0].set_ylim(sorted_IC_heat.shape[0], 0)\n", - "axes[0].set_yticks([0, sorted_IC_heat.shape[0]])\n", - "axes[0].set_yticklabels(['0', str(sorted_IC_heat.shape[0])])\n", - "axes[0].set_xticks(np.linspace(0, 400, 3))\n", + "axes[0].set_ylim(sorted_IC_heat.shape[0] - 0.5, -0.5) \n", + "axes[0].set_yticks([0, sorted_IC_heat.shape[0] - 1]) \n", + "axes[0].set_yticklabels(['0', str(sorted_IC_heat.shape[0] - 1)])\n", + "axes[0].set_xticks(np.linspace(0, sorted_IC_heat.shape[1] - 1, 3))\n", "axes[0].set_xticklabels(['0', '0.2', '0.4'])\n", "\n", - "\n", - "psth2 = axes[1].imshow(sorted_RE_heat, cmap='bwr', vmin=-50, vmax=50, aspect='auto', interpolation='nearest')\n", + "psth2 = axes[1].imshow(sorted_RE_heat, cmap='bwr', vmin=-30, vmax=30, aspect='auto', interpolation='nearest')\n", "fig.colorbar(psth2, ax=axes[1], label='ΔRate (Hz)')\n", - "axes[1].set_title('PSTH per Neuron')\n", + "axes[1].set_title('PSTH per Neuron (RE)')\n", "axes[1].set_xlabel('Time (s)')\n", "axes[1].set_ylabel('Neurons')\n", - "axes[1].set_ylim(sorted_RE_heat.shape[0], 0)\n", - "axes[1].set_yticks([0, sorted_RE_heat.shape[0]])\n", - "axes[1].set_yticklabels(['0', str(sorted_RE_heat.shape[0])])\n", - "axes[1].set_xticks(np.linspace(0, 400, 3))\n", + "axes[1].set_ylim(sorted_RE_heat.shape[0] - 0.5, -0.5)\n", + "axes[1].set_yticks([0, sorted_RE_heat.shape[0] - 1])\n", + "axes[1].set_yticklabels(['0', str(sorted_RE_heat.shape[0] - 1)])\n", + "axes[1].set_xticks(np.linspace(0, sorted_RE_heat.shape[1] - 1, 3))\n", "axes[1].set_xticklabels(['0', '0.2', '0.4'])\n", "\n", - "plt.tight_layout() \n", - "plt.show()\n" + "plt.tight_layout()\n", + "plt.show()" ] }, { @@ -3846,7 +4023,7 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -3917,7 +4094,7 @@ }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -3940,7 +4117,7 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ @@ -3963,7 +4140,7 @@ }, { "cell_type": "code", - "execution_count": 70, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ @@ -3975,7 +4152,7 @@ }, { "cell_type": "code", - "execution_count": 71, + "execution_count": 27, "metadata": {}, "outputs": [], "source": [ @@ -3991,7 +4168,7 @@ }, { "cell_type": "code", - "execution_count": 72, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ @@ -4003,7 +4180,7 @@ }, { "cell_type": "code", - "execution_count": 73, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ @@ -4020,7 +4197,7 @@ }, { "cell_type": "code", - "execution_count": 74, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ @@ -4037,7 +4214,7 @@ }, { "cell_type": "code", - "execution_count": 75, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ @@ -4047,7 +4224,7 @@ }, { "cell_type": "code", - "execution_count": 76, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -4058,12 +4235,12 @@ }, { "cell_type": "code", - "execution_count": 77, + "execution_count": 33, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -4077,7 +4254,7 @@ "\n", "\n", "plt.figure(figsize=(5, 4))\n", - "oris = plt.imshow(pref_ori, cmap='bwr', vmin=0, vmax=8)\n", + "oris = plt.imshow(pref_ori, cmap='bwr', vmin=0, vmax=2)\n", "plt.title('Orientation Preference')\n", "plt.xlabel('Pref. IC Orientation')\n", "plt.ylabel('Pref. RE Orientation')\n", @@ -4104,7 +4281,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.8" + "version": "3.12.2" } }, "nbformat": 4, From fe07e112e0df801d2a53905a23eecf61c5df8a5c Mon Sep 17 00:00:00 2001 From: KimYeerim Date: Fri, 28 Jun 2024 10:44:28 +0900 Subject: [PATCH 3/3] change session and enhance the clarity of graphs 1. Changed the session used for analysis to `sub-633229_ses-1199247593_ogen.nwb` to improve memory efficiency. 2. Enhanced the clarity of the graph by updating the color bars and other elements: - Adjusted the color range. - Updated color bar labels and ticks. --- docs/projects/illusion.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/projects/illusion.ipynb b/docs/projects/illusion.ipynb index 38f8b8db..1b7e204b 100644 --- a/docs/projects/illusion.ipynb +++ b/docs/projects/illusion.ipynb @@ -3079,7 +3079,7 @@ "nwb_ios = []\n", "for dandi_filepath in nwb_paths:\n", " # This can sometimes take a while depending on the size of the file\n", - " nwb_ios.append(dandi_download_open(dandiset_id, dandi_filepath, download_loc))" + " nwb_ios.append(dandi_download_open(dandiset_id, dandi_filepath, download_loc))\n" ] }, {