From cb22457f1fcbb7812fefe7e58a611ec4e10d934c Mon Sep 17 00:00:00 2001 From: Josh Siegle Date: Mon, 2 Dec 2019 10:52:52 -0800 Subject: [PATCH 01/27] ecephys_session notebook update --- .../examples/nb/ecephys_session.ipynb | 27 +++++++++++++++---- 1 file changed, 22 insertions(+), 5 deletions(-) diff --git a/doc_template/examples_root/examples/nb/ecephys_session.ipynb b/doc_template/examples_root/examples/nb/ecephys_session.ipynb index 38ab40863..6e47b5d69 100644 --- a/doc_template/examples_root/examples/nb/ecephys_session.ipynb +++ b/doc_template/examples_root/examples/nb/ecephys_session.ipynb @@ -82,11 +82,11 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ - "manifest_path = os.path.join(\"example_ecephys_project_cache\", \"manifest.json\")\n", + "manifest_path = os.path.join(\"/mnt/nvme0/ecephys_cache_dir\", \"manifest.json\")\n", "cache = EcephysProjectCache.from_warehouse(manifest=manifest_path)" ] }, @@ -1206,16 +1206,33 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "metadata": { "scrolled": false }, "outputs": [], "source": [ - "session_id = 756029989 # for example\n", + "session_id = 732592105 # for example\n", "session = cache.get_session_data(session_id)" ] }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "This ecephys session '732592105' has no eye tracking data. (NWB error: \"'eye_tracking' not found in modules of NWBFile 'root'\")\n" + ] + } + ], + "source": [ + "session.get_pupil_data()" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -5161,7 +5178,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.5" + "version": "3.6.8" }, "nbdime-conflicts": { "local_diff": [ From 41bc85d9da8d5eae143e798a0950c177dc1e0f5e Mon Sep 17 00:00:00 2001 From: Josh Siegle Date: Thu, 5 Dec 2019 12:27:04 -0800 Subject: [PATCH 02/27] Add more convenient alias for _get_rf --- .../ecephys/stimulus_analysis/receptive_field_mapping.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/allensdk/brain_observatory/ecephys/stimulus_analysis/receptive_field_mapping.py b/allensdk/brain_observatory/ecephys/stimulus_analysis/receptive_field_mapping.py index c7cd4ae3b..3d849c1ad 100644 --- a/allensdk/brain_observatory/ecephys/stimulus_analysis/receptive_field_mapping.py +++ b/allensdk/brain_observatory/ecephys/stimulus_analysis/receptive_field_mapping.py @@ -184,6 +184,12 @@ def _get_stim_table_stats(self): self._pos_x = np.sort(self.stimulus_conditions.loc[self.stimulus_conditions[self._col_pos_x] != 'null'][self._col_pos_x].unique()) + def get_receptive_field(self, unit_id): + """ Alias for _get_rf + """ + + return self._get_rf(unit_id) + def _get_rf(self, unit_id): """ Extract the receptive field for one unit From f3ab86fb25354ffb44d0bfea400ee3c9f023f0ca Mon Sep 17 00:00:00 2001 From: Josh Siegle Date: Thu, 5 Dec 2019 12:33:14 -0800 Subject: [PATCH 03/27] Revert nb changes --- .../examples/nb/ecephys_session.ipynb | 23 +++---------------- 1 file changed, 3 insertions(+), 20 deletions(-) diff --git a/doc_template/examples_root/examples/nb/ecephys_session.ipynb b/doc_template/examples_root/examples/nb/ecephys_session.ipynb index 8e6da1327..5777d1d7c 100644 --- a/doc_template/examples_root/examples/nb/ecephys_session.ipynb +++ b/doc_template/examples_root/examples/nb/ecephys_session.ipynb @@ -82,7 +82,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -1207,33 +1207,16 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": { "scrolled": false }, "outputs": [], "source": [ - "session_id = 732592105 # for example\n", + "session_id = 756029989 # for example\n", "session = cache.get_session_data(session_id)" ] }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "This ecephys session '732592105' has no eye tracking data. (NWB error: \"'eye_tracking' not found in modules of NWBFile 'root'\")\n" - ] - } - ], - "source": [ - "session.get_pupil_data()" - ] - }, { "cell_type": "markdown", "metadata": {}, From 391459e7ee28440b61d4f5cecb2696977d3a6934 Mon Sep 17 00:00:00 2001 From: "!git for-each-ref --format='%(refname:short)' `git symbolic-ref HEAD`" Date: Sun, 9 Feb 2020 19:40:30 -0800 Subject: [PATCH 04/27] version and cache spec --- .../ecephys/nwb/AIBS_ecephys_namespace.yaml | 1 + allensdk/brain_observatory/ecephys/write_nwb/__main__.py | 7 +++---- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/allensdk/brain_observatory/ecephys/nwb/AIBS_ecephys_namespace.yaml b/allensdk/brain_observatory/ecephys/nwb/AIBS_ecephys_namespace.yaml index 658ea895b..142bad888 100644 --- a/allensdk/brain_observatory/ecephys/nwb/AIBS_ecephys_namespace.yaml +++ b/allensdk/brain_observatory/ecephys/nwb/AIBS_ecephys_namespace.yaml @@ -1,5 +1,6 @@ namespaces: - doc: "" + version: 0.2.0 name: AIBS_ecephys schema: - namespace: core diff --git a/allensdk/brain_observatory/ecephys/write_nwb/__main__.py b/allensdk/brain_observatory/ecephys/write_nwb/__main__.py index d67fab6ab..3a3fab087 100644 --- a/allensdk/brain_observatory/ecephys/write_nwb/__main__.py +++ b/allensdk/brain_observatory/ecephys/write_nwb/__main__.py @@ -775,10 +775,9 @@ def write_ecephys_nwb( eye_gaze_data=eye_gaze_data) Manifest.safe_make_parent_dirs(output_path) - io = pynwb.NWBHDF5IO(output_path, mode='w') - logging.info(f"writing session nwb file to {output_path}") - io.write(nwbfile) - io.close() + with pynwb.NWBHDF5IO(output_path, mode='w') as io: + logging.info(f"writing session nwb file to {output_path}") + io.write(nwbfile, cache_spec=True) probes_with_lfp = [p for p in probes if p["lfp"] is not None] probe_outputs = write_probewise_lfp_files(probes_with_lfp, session_start_time, pool_size=pool_size) From 8614d74edeef6c1c00709bc878557da2c3c3c150 Mon Sep 17 00:00:00 2001 From: "!git for-each-ref --format='%(refname:short)' `git symbolic-ref HEAD`" Date: Sun, 9 Feb 2020 20:17:22 -0800 Subject: [PATCH 05/27] add version to AIBS_ophys_behavior --- .../brain_observatory/nwb/AIBS_ophys_behavior_namespace.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/allensdk/brain_observatory/nwb/AIBS_ophys_behavior_namespace.yaml b/allensdk/brain_observatory/nwb/AIBS_ophys_behavior_namespace.yaml index b9f3d1822..b6c5c45cd 100644 --- a/allensdk/brain_observatory/nwb/AIBS_ophys_behavior_namespace.yaml +++ b/allensdk/brain_observatory/nwb/AIBS_ophys_behavior_namespace.yaml @@ -2,6 +2,7 @@ namespaces: - doc: "LabMetaData extensions: ['OphysBehaviorMetaData', 'OphysBehaviorTaskParameters']\ \ (AIBS_ophys_behavior)" name: AIBS_ophys_behavior + version: 0.1.0 schema: - namespace: core - source: AIBS_ophys_behavior_extension.yaml From 159818456957b324500bb2b9842da46ae40aa85c Mon Sep 17 00:00:00 2001 From: Yaroslav Halchenko Date: Tue, 18 Feb 2020 16:06:50 -0500 Subject: [PATCH 06/27] [DATALAD RUNCMD] minor typo === Do not change lines below === { "chain": [], "cmd": "git-sedi ininformative uninformative", "exit": 0, "extra_inputs": [], "inputs": [], "outputs": [], "pwd": "." } ^^^ Do not change lines above ^^^ --- allensdk/core/brain_observatory_nwb_data_set.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/allensdk/core/brain_observatory_nwb_data_set.py b/allensdk/core/brain_observatory_nwb_data_set.py index bf8a1227f..69d437c4a 100755 --- a/allensdk/core/brain_observatory_nwb_data_set.py +++ b/allensdk/core/brain_observatory_nwb_data_set.py @@ -218,7 +218,7 @@ def get_stimulus_epoch_table(self): 'duration':duration_signature_list, 'interval':interval_signature_list}) - # Gaps are ininformative; remove them: + # Gaps are uninformative; remove them: interval_df = interval_df[interval_df.stimulus != 'gap'] interval_df['start'] = [x[0] for x in interval_df['interval'].values] interval_df['end'] = [x[1] for x in interval_df['interval'].values] From f172f4a6b9eb1ce970e3c6fde22bc48b12f76c84 Mon Sep 17 00:00:00 2001 From: "isaak.willett@alleninstitute.org" Date: Thu, 20 Feb 2020 12:51:57 -0800 Subject: [PATCH 07/27] Fixed bug requiring additional IDs for BehaviorDataLimsApi Previously BehaviorDataLimsApi would raise an exception if no container id was returned from lims id for given ophys id. This has been changed at allenskd/internal/api/behavior_data_lims_api.py 105 - 108. Now the query will return None for the container id if the query results in an empty list return. Resolves: #1354 --- allensdk/internal/api/behavior_data_lims_api.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/allensdk/internal/api/behavior_data_lims_api.py b/allensdk/internal/api/behavior_data_lims_api.py index 3c544632f..00d71ddd8 100644 --- a/allensdk/internal/api/behavior_data_lims_api.py +++ b/allensdk/internal/api/behavior_data_lims_api.py @@ -102,7 +102,10 @@ def _get_ids(self) -> Dict[str, Optional[Union[int, List[int]]]]: WHERE ophys_experiment_id IN ({",".join(set(map(str, oed)))}); """ - container_id = self.lims_db.fetchone(container_query, strict=True) + try: + container_id = self.lims_db.fetchone(container_query, strict=True) + except OneResultExpectedError: + container_id = None ids_dict.update({"ophys_experiment_ids": oed, "ophys_container_id": container_id}) From 08808db5bedbde7e4285c48ae695417f6ded092f Mon Sep 17 00:00:00 2001 From: "isaak.willett@alleninstitute.org" Date: Thu, 20 Feb 2020 14:21:05 -0800 Subject: [PATCH 08/27] Return None instead of empty list if there are no ophys_experiment_ids --- allensdk/internal/api/behavior_data_lims_api.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/allensdk/internal/api/behavior_data_lims_api.py b/allensdk/internal/api/behavior_data_lims_api.py index 00d71ddd8..a2d7087b3 100644 --- a/allensdk/internal/api/behavior_data_lims_api.py +++ b/allensdk/internal/api/behavior_data_lims_api.py @@ -93,6 +93,8 @@ def _get_ids(self) -> Dict[str, Optional[Union[int, List[int]]]]: WHERE ophys_session_id = {ids_dict["ophys_session_id"]}; """ oed = self.lims_db.fetchall(oed_query) + if len(oed) == 0: + oed = None container_query = f""" SELECT DISTINCT From 8a87938a59c0151d89da339c6e02841910400e7d Mon Sep 17 00:00:00 2001 From: Josh Siegle Date: Mon, 2 Dec 2019 10:52:52 -0800 Subject: [PATCH 09/27] ecephys_session notebook update --- .../examples/nb/ecephys_session.ipynb | 23 ++++++++++++++++--- 1 file changed, 20 insertions(+), 3 deletions(-) diff --git a/doc_template/examples_root/examples/nb/ecephys_session.ipynb b/doc_template/examples_root/examples/nb/ecephys_session.ipynb index 5777d1d7c..8e6da1327 100644 --- a/doc_template/examples_root/examples/nb/ecephys_session.ipynb +++ b/doc_template/examples_root/examples/nb/ecephys_session.ipynb @@ -82,7 +82,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -1207,16 +1207,33 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "metadata": { "scrolled": false }, "outputs": [], "source": [ - "session_id = 756029989 # for example\n", + "session_id = 732592105 # for example\n", "session = cache.get_session_data(session_id)" ] }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "This ecephys session '732592105' has no eye tracking data. (NWB error: \"'eye_tracking' not found in modules of NWBFile 'root'\")\n" + ] + } + ], + "source": [ + "session.get_pupil_data()" + ] + }, { "cell_type": "markdown", "metadata": {}, From 9dd76d3fe6032cd7acf8e0189d02d980550abc67 Mon Sep 17 00:00:00 2001 From: Josh Siegle Date: Thu, 20 Feb 2020 14:50:53 -0800 Subject: [PATCH 10/27] Add optotagging tutorial --- .../examples/nb/ecephys_optotagging.ipynb | 1312 +++++++++++++++++ doc_template/visual_coding_neuropixels.rst | 1 + 2 files changed, 1313 insertions(+) create mode 100644 doc_template/examples_root/examples/nb/ecephys_optotagging.ipynb diff --git a/doc_template/examples_root/examples/nb/ecephys_optotagging.ipynb b/doc_template/examples_root/examples/nb/ecephys_optotagging.ipynb new file mode 100644 index 000000000..8455d12cc --- /dev/null +++ b/doc_template/examples_root/examples/nb/ecephys_optotagging.ipynb @@ -0,0 +1,1312 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Optotagging Analysis\n", + "\n", + "## Tutorial overview\n", + "\n", + "This Jupyter notebook will demonstrate how to analyze responses to optotagging stimuli in Neuropixels Brain Observatory datasets. Optotagging makes it possible to link _in vivo_ spike trains to genetically defined cell classes. By expressing a light-gated ion channel (in this case, ChR2) in a Cre-dependent manner, we can activate Cre+ neurons with light pulses delivered to the cortical surface. Units that fire action potentials in response to these light pulses are likely to express the gene of interest.\n", + "\n", + "Of course, there are some shortcomings to this approach, most notably that the presence of light artifacts can create the appearance of false positives, and that false negatives (cells that are Cre+ but do not respond to light) are nearly impossible to avoid. We will explain how to deal with these caveats in order to incorporate the available cell type information into your analyses.\n", + "\n", + "This tutorial will cover the following topics:\n", + "\n", + "* Finding datasets of interest\n", + "* Types of optotagging stimuli\n", + "* Aligning spikes to light pulses\n", + "* Identifying Cre+ units\n", + "* Differences across genotypes\n", + "\n", + "This tutorial assumes you've already created a data cache, or are working with NWB files on AWS. If you haven't reached that step yet, we recommend going through the [data access tutorial](./ecephys_data_access.ipynb) first.\n", + "\n", + "Functions related to analyzing responses to visual stimuli will be covered in other tutorials. For a full list of available tutorials, see the [SDK documentation](https://allensdk.readthedocs.io/en/latest/visual_coding_neuropixels.html)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, let's deal with the necessary imports:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import xarray as xr\n", + "\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "from allensdk.brain_observatory.ecephys.ecephys_project_cache import EcephysProjectCache" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we'll create an `EcephysProjectCache` object that points to a new or existing manifest file.\n", + "\n", + "If you're not sure what a manifest file is or where to put it, please check out [this tutorial](./ecephys_data_access.ipynb) before going further." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "data_directory = '/mnt/nvme0/ecephys_cache_dir'\n", + "\n", + "manifest_path = os.path.join(data_directory, \"manifest.json\")\n", + "\n", + "cache = EcephysProjectCache.from_warehouse(manifest=manifest_path)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Finding datasets of interest" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `sessions` table contains information about all the experiments available in the `EcephysProjectCache`. The `full_genotype` column contains information about the genotype of the mouse used in each experiment." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "wt/wt 30\n", + "Sst-IRES-Cre/wt;Ai32(RCL-ChR2(H134R)_EYFP)/wt 12\n", + "Pvalb-IRES-Cre/wt;Ai32(RCL-ChR2(H134R)_EYFP)/wt 8\n", + "Vip-IRES-Cre/wt;Ai32(RCL-ChR2(H134R)_EYFP)/wt 8\n", + "Name: full_genotype, dtype: int64" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sessions = cache.get_session_table()\n", + "\n", + "sessions.full_genotype.value_counts()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "About half the mice are wild type (`wt/wt`), while the other half are a cross between a Cre line and the Ai32 reporter line. The Cre mice express ChR2 in one of three interneuron subtypes: Parvalbumin-positive neurons (`Pvalb`), Somatostatin-positive neurons (`Sst`), and Vasoactive Intestinal Polypeptide neurons (`Vip`). We know that these genes are expressed in largely non-overlapping populations of inhibitory cells, and that, taken together, they [cover nearly the entire range of cortical GABAergic neurons](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3556905/#!po=8.92857), with the caveat that VIP+ cells are a subset of a larger group of 5HT3aR-expressing cells.\n", + "\n", + "To find experiments performed on a specific genotype, we can filter the sessions table on the `full_genotype` column:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
published_atspecimen_idsession_typeage_in_dayssexfull_genotypeunit_countchannel_countprobe_countecephys_structure_acronyms
id
7211238222019-10-03T00:00:00Z707296982brain_observatory_1.1125.0MPvalb-IRES-Cre/wt;Ai32(RCL-ChR2(H134R)_EYFP)/wt44422296[MB, SCig, PPT, NOT, DG, CA1, VISam, nan, LP, ...
7460839552019-10-03T00:00:00Z726170935brain_observatory_1.198.0FPvalb-IRES-Cre/wt;Ai32(RCL-ChR2(H134R)_EYFP)/wt58222166[VPM, TH, LGd, CA3, CA2, CA1, VISal, nan, grey...
7603457022019-10-03T00:00:00Z739783171brain_observatory_1.1103.0MPvalb-IRES-Cre/wt;Ai32(RCL-ChR2(H134R)_EYFP)/wt50118625[MB, TH, PP, PIL, DG, CA3, CA1, VISal, nan, gr...
7734189062019-10-03T00:00:00Z757329624brain_observatory_1.1124.0FPvalb-IRES-Cre/wt;Ai32(RCL-ChR2(H134R)_EYFP)/wt54622326[PPT, NOT, SUB, ProS, CA1, VISam, nan, APN, DG...
7978283572019-10-03T00:00:00Z776061251brain_observatory_1.1107.0MPvalb-IRES-Cre/wt;Ai32(RCL-ChR2(H134R)_EYFP)/wt61122326[PPT, MB, APN, NOT, HPF, ProS, CA1, VISam, nan...
8297207052019-10-03T00:00:00Z811322619functional_connectivity112.0MPvalb-IRES-Cre/wt;Ai32(RCL-ChR2(H134R)_EYFP)/wt52918415[SCig, SCop, SCsg, SCzo, POST, VISp, nan, CA1,...
8395576292019-10-03T00:00:00Z821469666functional_connectivity115.0MPvalb-IRES-Cre/wt;Ai32(RCL-ChR2(H134R)_EYFP)/wt45018535[APN, NOT, MB, DG, CA1, VISam, nan, VISpm, LGd...
8400120442019-10-03T00:00:00Z820866121functional_connectivity116.0MPvalb-IRES-Cre/wt;Ai32(RCL-ChR2(H134R)_EYFP)/wt75822986[APN, DG, CA1, VISam, nan, LP, VISpm, VISp, LG...
\n", + "
" + ], + "text/plain": [ + " published_at specimen_id session_type \\\n", + "id \n", + "721123822 2019-10-03T00:00:00Z 707296982 brain_observatory_1.1 \n", + "746083955 2019-10-03T00:00:00Z 726170935 brain_observatory_1.1 \n", + "760345702 2019-10-03T00:00:00Z 739783171 brain_observatory_1.1 \n", + "773418906 2019-10-03T00:00:00Z 757329624 brain_observatory_1.1 \n", + "797828357 2019-10-03T00:00:00Z 776061251 brain_observatory_1.1 \n", + "829720705 2019-10-03T00:00:00Z 811322619 functional_connectivity \n", + "839557629 2019-10-03T00:00:00Z 821469666 functional_connectivity \n", + "840012044 2019-10-03T00:00:00Z 820866121 functional_connectivity \n", + "\n", + " age_in_days sex full_genotype \\\n", + "id \n", + "721123822 125.0 M Pvalb-IRES-Cre/wt;Ai32(RCL-ChR2(H134R)_EYFP)/wt \n", + "746083955 98.0 F Pvalb-IRES-Cre/wt;Ai32(RCL-ChR2(H134R)_EYFP)/wt \n", + "760345702 103.0 M Pvalb-IRES-Cre/wt;Ai32(RCL-ChR2(H134R)_EYFP)/wt \n", + "773418906 124.0 F Pvalb-IRES-Cre/wt;Ai32(RCL-ChR2(H134R)_EYFP)/wt \n", + "797828357 107.0 M Pvalb-IRES-Cre/wt;Ai32(RCL-ChR2(H134R)_EYFP)/wt \n", + "829720705 112.0 M Pvalb-IRES-Cre/wt;Ai32(RCL-ChR2(H134R)_EYFP)/wt \n", + "839557629 115.0 M Pvalb-IRES-Cre/wt;Ai32(RCL-ChR2(H134R)_EYFP)/wt \n", + "840012044 116.0 M Pvalb-IRES-Cre/wt;Ai32(RCL-ChR2(H134R)_EYFP)/wt \n", + "\n", + " unit_count channel_count probe_count \\\n", + "id \n", + "721123822 444 2229 6 \n", + "746083955 582 2216 6 \n", + "760345702 501 1862 5 \n", + "773418906 546 2232 6 \n", + "797828357 611 2232 6 \n", + "829720705 529 1841 5 \n", + "839557629 450 1853 5 \n", + "840012044 758 2298 6 \n", + "\n", + " ecephys_structure_acronyms \n", + "id \n", + "721123822 [MB, SCig, PPT, NOT, DG, CA1, VISam, nan, LP, ... \n", + "746083955 [VPM, TH, LGd, CA3, CA2, CA1, VISal, nan, grey... \n", + "760345702 [MB, TH, PP, PIL, DG, CA3, CA1, VISal, nan, gr... \n", + "773418906 [PPT, NOT, SUB, ProS, CA1, VISam, nan, APN, DG... \n", + "797828357 [PPT, MB, APN, NOT, HPF, ProS, CA1, VISam, nan... \n", + "829720705 [SCig, SCop, SCsg, SCzo, POST, VISp, nan, CA1,... \n", + "839557629 [APN, NOT, MB, DG, CA1, VISam, nan, VISpm, LGd... \n", + "840012044 [APN, DG, CA1, VISam, nan, LP, VISpm, VISp, LG... " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pvalb_sessions = sessions[sessions.full_genotype.str.match('Pvalb')]\n", + "\n", + "pvalb_sessions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The table above contains 8 sessions, 5 of which used the `brain_observatory_1.1` visual stimulus, and 3 of which used the `functional_connectivity` stimulus. Any experiments with the same stimulus set are identical across genotypes. Importantly, the optotagging stimulus does not occur until the end of the experiment, so any changes induced by activating a specific set of interneurons will not affect the visual responses that we measure." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Types of optotagging stimuli" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's load one of the above sessions to see how to extract information about the optotagging stimuli that were delivered." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "session = cache.get_session_data(pvalb_sessions.index.values[-3])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The optotagging stimulus table is stored separately from the visual stimulus table. So instead of calling `session.stimulus_presentations`, we will use `session.optogenetic_stimulation_epochs` to load a DataFrame that contains the information about the optotagging stimuli:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
start_timestop_timeconditionlevelnameduration
id
09208.460449208.46544a single square pulse2.0pulse0.005
19210.640629210.65062a single square pulse1.7pulse0.010
29212.370649213.370642.5 ms pulses at 10 Hz1.7fast_pulses1.000
39214.400769215.400762.5 ms pulses at 10 Hz1.3fast_pulses1.000
49216.550919217.550912.5 ms pulses at 10 Hz2.0fast_pulses1.000
.....................
2959778.775169779.775162.5 ms pulses at 10 Hz2.0fast_pulses1.000
2969780.725309781.72530half-period of a cosine wave2.0raised_cosine1.000
2979782.665289782.67028a single square pulse1.3pulse0.005
2989784.815389784.82038a single square pulse1.3pulse0.005
2999786.605479786.61547a single square pulse1.3pulse0.010
\n", + "

300 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " start_time stop_time condition level \\\n", + "id \n", + "0 9208.46044 9208.46544 a single square pulse 2.0 \n", + "1 9210.64062 9210.65062 a single square pulse 1.7 \n", + "2 9212.37064 9213.37064 2.5 ms pulses at 10 Hz 1.7 \n", + "3 9214.40076 9215.40076 2.5 ms pulses at 10 Hz 1.3 \n", + "4 9216.55091 9217.55091 2.5 ms pulses at 10 Hz 2.0 \n", + ".. ... ... ... ... \n", + "295 9778.77516 9779.77516 2.5 ms pulses at 10 Hz 2.0 \n", + "296 9780.72530 9781.72530 half-period of a cosine wave 2.0 \n", + "297 9782.66528 9782.67028 a single square pulse 1.3 \n", + "298 9784.81538 9784.82038 a single square pulse 1.3 \n", + "299 9786.60547 9786.61547 a single square pulse 1.3 \n", + "\n", + " name duration \n", + "id \n", + "0 pulse 0.005 \n", + "1 pulse 0.010 \n", + "2 fast_pulses 1.000 \n", + "3 fast_pulses 1.000 \n", + "4 fast_pulses 1.000 \n", + ".. ... ... \n", + "295 fast_pulses 1.000 \n", + "296 raised_cosine 1.000 \n", + "297 pulse 0.005 \n", + "298 pulse 0.005 \n", + "299 pulse 0.010 \n", + "\n", + "[300 rows x 6 columns]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "session.optogenetic_stimulation_epochs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This returns a table with information about each optotagging trial. To find the unique conditions across all trials, we can use the following Pandas syntax:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
conditionlevelnameduration
id
32.5 ms pulses at 10 Hz1.3fast_pulses1.000
22.5 ms pulses at 10 Hz1.7fast_pulses1.000
42.5 ms pulses at 10 Hz2.0fast_pulses1.000
17a single square pulse1.3pulse0.005
7a single square pulse1.7pulse0.005
0a single square pulse2.0pulse0.005
13a single square pulse1.3pulse0.010
1a single square pulse1.7pulse0.010
8a single square pulse2.0pulse0.010
5half-period of a cosine wave1.3raised_cosine1.000
14half-period of a cosine wave1.7raised_cosine1.000
6half-period of a cosine wave2.0raised_cosine1.000
\n", + "
" + ], + "text/plain": [ + " condition level name duration\n", + "id \n", + "3 2.5 ms pulses at 10 Hz 1.3 fast_pulses 1.000\n", + "2 2.5 ms pulses at 10 Hz 1.7 fast_pulses 1.000\n", + "4 2.5 ms pulses at 10 Hz 2.0 fast_pulses 1.000\n", + "17 a single square pulse 1.3 pulse 0.005\n", + "7 a single square pulse 1.7 pulse 0.005\n", + "0 a single square pulse 2.0 pulse 0.005\n", + "13 a single square pulse 1.3 pulse 0.010\n", + "1 a single square pulse 1.7 pulse 0.010\n", + "8 a single square pulse 2.0 pulse 0.010\n", + "5 half-period of a cosine wave 1.3 raised_cosine 1.000\n", + "14 half-period of a cosine wave 1.7 raised_cosine 1.000\n", + "6 half-period of a cosine wave 2.0 raised_cosine 1.000" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "columns = ['name', 'duration','level']\n", + "\n", + "session.optogenetic_stimulation_epochs.drop_duplicates(columns).sort_values(by=columns).drop(columns=['start_time','stop_time'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The optotagging portion of the experiment includes four categories of blue light stimuli: 2.5 ms pulses delivered at 10 Hz for one second, a single 5 ms pulse, a single 10 ms pulse, and a raised cosine pulse lasting 1 second. All of these stimuli are delivered through a 400 micron-diameter fiber optic cable positioned to illuminate the surface of visual cortex. Each stimulus is delivered at one of three power levels, defined by the peak voltage of the control signal delivered to the light source, not the actual light power at the tip of the fiber.\n", + "\n", + "Unfortunately, light power has not been perfectly matched across experiments. A little more than halfway through the data collection process, we switched from delivering light through an LED (maximum power at fiber tip = 4 mW) to a laser (maximum power at fiber tip = 35 mW), in order to evoke more robust optotagging responses. To check whether or not a particular experiment used a laser, you can use the following filter:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sessions.index.values >= 789848216" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We realize that this makes it more difficult to compare results across experiments, but we decided it was better to improve the optotagging yield for later sessions than continue to use light levels that were not reliably driving spiking responses." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Aligning spikes to light pulses" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Aligning spikes to light pulses is a bit more involved than aligning spikes to visual stimuli. This is because we haven't yet created convenience functions for performing this alignment automatically, such as `session.presentationwise_spike_times` or `sesssion.presentationwise_spike_counts`. We are planning to incorporate such functions into the AllenSDK in the future, but for now, you'll have to write your own code for extracting spikes around light pulses (or copy the code below).\n", + "\n", + "Let's choose a stimulus condition (10 ms pulses) and a set of units (visual cortex only), then create a DataArray containing binned spikes aligned to the start of each stimulus." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "trials = session.optogenetic_stimulation_epochs[(session.optogenetic_stimulation_epochs.duration > 0.009) & \\\n", + " (session.optogenetic_stimulation_epochs.duration < 0.02)]\n", + "\n", + "units = session.units[session.units.ecephys_structure_acronym.str.match('VIS')]\n", + "\n", + "time_resolution = 0.0005 # 0.5 ms bins\n", + "\n", + "bin_edges = np.arange(-0.01, 0.025, time_resolution)\n", + "\n", + "def optotagging_spike_counts(bin_edges, trials, units):\n", + " \n", + " time_resolution = np.mean(np.diff(bin_edges))\n", + "\n", + " spike_matrix = np.zeros( (len(trials), len(bin_edges), len(units)) )\n", + "\n", + " for unit_idx, unit_id in enumerate(units.index.values):\n", + "\n", + " spike_times = session.spike_times[unit_id]\n", + "\n", + " for trial_idx, trial_start in enumerate(trials.start_time.values):\n", + "\n", + " in_range = (spike_times > (trial_start + bin_edges[0])) * \\\n", + " (spike_times < (trial_start + bin_edges[-1]))\n", + "\n", + " binned_times = ((spike_times[in_range] - (trial_start + bin_edges[0])) / time_resolution).astype('int')\n", + " spike_matrix[trial_idx, binned_times, unit_idx] = 1\n", + "\n", + " return xr.DataArray(\n", + " name='spike_counts',\n", + " data=spike_matrix,\n", + " coords={\n", + " 'trial_id': trials.index.values,\n", + " 'time_relative_to_stimulus_onset': bin_edges,\n", + " 'unit_id': units.index.values\n", + " },\n", + " dims=['trial_id', 'time_relative_to_stimulus_onset', 'unit_id']\n", + " )\n", + "\n", + "da = optotagging_spike_counts(bin_edges, trials, units)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can use this DataArray to plot the average firing rate for each unit as a function of time:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def plot_optotagging_response(da):\n", + "\n", + " plt.figure(figsize=(5,10))\n", + "\n", + " plt.imshow(da.mean(dim='trial_id').T / time_resolution, \n", + " extent=[np.min(bin_edges), np.max(bin_edges),\n", + " 0, len(units)],\n", + " aspect='auto', vmin=0, vmax=200) \n", + "\n", + " for bound in [0.0005, 0.0095]:\n", + " plt.plot([bound, bound],[0, len(units)], ':', color='white', linewidth=1.0)\n", + "\n", + " plt.xlabel('Time (s)')\n", + " plt.ylabel('Unit #')\n", + "\n", + " cb = plt.colorbar(fraction=0.046, pad=0.04)\n", + " cb.set_label('Mean firing rate (Hz)')\n", + " \n", + "plot_optotagging_response(da)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this plot, we can see that a number of units increase their firing rate during the stimulus window, firing a burst of around three spikes. This is typical for Parvalbumin-positive neurons, which fire at high rates under natural conditions.\n", + "\n", + "However, there are also some units that seem to fire at the very beginning and/or very end of the light pulse. These spikes are almost certainly artifactual, as it takes at least 1 ms to generate a true light-evoked action potential. Therefore, we need to disregard these low-latency \"spikes\" in our analysis." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Identifying Cre+ units" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we know how to align spikes, we can start assessing which units are reliably driven by the optotagging stimulus and are likely to be Cre+.\n", + "\n", + "There are a variety of ways to do this, but these are the most important things to keep in mind:\n", + "* Spikes that occur precisely at the start or end of a light pulse are likely artifactual, and need to be ignored.\n", + "* The bright blue light required for optotagging _can_ be seen by the mouse, so any spikes that occur more than 40 ms after the stimulus onset may result from retinal input, as opposed to direct optogenetic drive.\n", + "* The rate of false negatives (Cre+ cells that are not light-driven) will vary across areas, across depths, and across sessions. We've tried our best to evenly illuminate the entire visual cortex, and to use light powers that can drive spikes throughout all cortical layers, but some variation is inevitable.\n", + "\n", + "For these reasons, we've found that the 10 ms pulses are the most useful stimulus for finding true light-evoked activity. These pulses provide a long enough artifact-free window to observe light-evoked spikes, but do not last long enough to be contaminated by visually driven activity.\n", + "\n", + "Using the DataArray we created previously, we can search for units that increase their firing rate during the 10 ms pulse:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "baseline = da.sel(time_relative_to_stimulus_onset=slice(-0.01,-0.002))\n", + "\n", + "baseline_rate = baseline.sum(dim='time_relative_to_stimulus_onset').mean(dim='trial_id') / 0.008\n", + "\n", + "evoked = da.sel(time_relative_to_stimulus_onset=slice(0.001,0.009))\n", + "\n", + "evoked_rate = evoked.sum(dim='time_relative_to_stimulus_onset').mean(dim='trial_id') / 0.008" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Comparing the baseline and evoked rates, we can see a clear subset of units with a light-evoked increase in firing rate:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(5,5))\n", + "\n", + "plt.scatter(baseline_rate, evoked_rate, s=3)\n", + "\n", + "axis_limit = 250\n", + "plt.plot([0,axis_limit],[0,axis_limit], ':k')\n", + "plt.plot([0,axis_limit],[0,axis_limit*2], ':r')\n", + "plt.xlim([0,axis_limit])\n", + "plt.ylim([0,axis_limit])\n", + "\n", + "plt.xlabel('Baseline rate (Hz)')\n", + "_ = plt.ylabel('Evoked rate (Hz)')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can select a threshold, such as 2x increase in firing rate (red line) to find the IDs for units that are robustly driven by the light:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([951131472, 951131470, 951131486, 951131478, 951131522, 951131506,\n", + " 951131782, 951131534, 951131558, 951131556, 951131564, 951131560,\n", + " 951131581, 951131589, 951131583, 951131593, 951131612, 951131643,\n", + " 951131689, 951132054, 951132138, 951132140, 951132159, 951132184,\n", + " 951132212, 951132205, 951132224, 951132236, 951133681, 951133822,\n", + " 951133909, 951134030, 951134026, 951134066, 951134100, 951134199,\n", + " 951136071, 951136175, 951136247, 951136394, 951136657, 951136717,\n", + " 951136829, 951137028, 951137073, 951137204, 951140485, 951140617,\n", + " 951141942, 951140861, 951140832, 951140821, 951141065, 951141978,\n", + " 951141097, 951141154, 951141292, 951141373, 951141485, 951141536])" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cre_pos_units = da.unit_id[(evoked_rate / (baseline_rate + 1)) > 2].values # add 1 to prevent divide-by-zero errors\n", + "\n", + "cre_pos_units" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Because this is a Parvalbumin-Cre mouse, we expect the majority of light-driven units to be fast-spiking interneurons. We can check this by plotting the mean waveforms for the units we've identified." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(5,5))\n", + "\n", + "for unit_id in cre_pos_units:\n", + " \n", + " peak_channel = session.units.loc[unit_id].peak_channel_id\n", + " wv = session.mean_waveforms[unit_id].sel(channel_id = peak_channel)\n", + " \n", + " plt.plot(wv.time * 1000, wv, 'k', alpha=0.3)\n", + "\n", + "plt.xlabel('Time (ms)')\n", + "plt.ylabel('Amplitude (microvolts)')\n", + "_ =plt.plot([1.0, 1.0],[-160, 100],':c')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Indeed, most of these units have stereotypical \"fast-spiking\" waveforms (with a peak earlier than 1 ms). The outliers are likely parvalbumin-positive pyramidal cells." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Differences across genotypes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The example above is a \"best-case\" scenario. As you look across experiments, you will find that there is substantial variability in the fraction of light-driven neurons. Some of this can be accounted for by differences in light power. But much of the variability can be attributed to genotype: parvalbumin+ cells are the most abundant type of inhibitory cells in the cortex, with somastatin+ cells coming next, and VIP+ cells a distant third. There are also likely differences in our ability to record from different interneuron subtypes. For example, parvalbumin+ cells generally fire at the highest rates, which makes them easier to detect in extracellular electrophysiology experiments. The size of the cell's soma also plays a role in its recordability, and this likely varies across interneuron sub-classes.\n", + "\n", + "Overall, it is clear that VIP+ cells have proven the most difficult to identify through optotagging methods. The VIP-Cre mice we've recorded contain _very_ few light-driven units: the number is on the order of one per probe, and is sometimes zero across the whole experiment. We're not yet sure whether this is due to the difficultly of recording VIP+ cells with Neuropixels probes, or the difficulty of driving them with ChR2. To confounding things even further, VIP+ cells tend to have a _disinhibitory_ effect on the local circuit, so units that significantly increase their firing during the 1 s raised cosine light stimulus are not guaranteed to be Cre+.\n", + "\n", + "In any case, it will be helpful to look at some characteristic examples of light-evoked responses in Sst-Cre and Vip-Cre mice, so you know what to expect." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "sst_sessions = sessions[sessions.full_genotype.str.match('Sst')]\n", + "\n", + "session = cache.get_session_data(sst_sessions.index.values[-1])" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "trials = session.optogenetic_stimulation_epochs[(session.optogenetic_stimulation_epochs.duration > 0.009) & \\\n", + " (session.optogenetic_stimulation_epochs.duration < 0.02)]\n", + "\n", + "units = session.units[session.units.ecephys_structure_acronym.str.match('VIS')]\n", + "\n", + "bin_edges = np.arange(-0.01, 0.025, 0.0005)\n", + "\n", + "da = optotagging_spike_counts(bin_edges, trials, units)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_optotagging_response(da)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this Sst-Cre mouse, we see a smaller fraction of light-driven units than in the Pvalb-Cre mouse. The light-driven units tend to spike at a range of latencies following light onset, rather than displaying the rhythmic firing pattern of Parvalbumin+ cells. Again, note that the spikes that are precisely aligned to the light onset or offset are likely artifactual.\n", + "\n", + "Now that we've computed the average responses, we can use the same method as above to find the units that are activated by the light." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "baseline = da.sel(time_relative_to_stimulus_onset=slice(-0.01,-0.002))\n", + "\n", + "baseline_rate = baseline.sum(dim='time_relative_to_stimulus_onset').mean(dim='trial_id') / 0.008\n", + "\n", + "evoked = da.sel(time_relative_to_stimulus_onset=slice(0.001,0.009))\n", + "\n", + "evoked_rate = evoked.sum(dim='time_relative_to_stimulus_onset').mean(dim='trial_id') / 0.008" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(5,5))\n", + "\n", + "plt.scatter(baseline_rate, evoked_rate, s=3)\n", + "\n", + "axis_limit = 175\n", + "plt.plot([0,axis_limit],[0,axis_limit], ':k')\n", + "plt.plot([0,axis_limit],[0,axis_limit*2], ':r')\n", + "plt.xlim([0,axis_limit])\n", + "plt.ylim([0,axis_limit])\n", + "\n", + "plt.xlabel('Baseline rate (Hz)')\n", + "_ = plt.ylabel('Evoked rate (Hz)')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are a smaller fraction of light-driven units in this Sst-Cre mouse, but the effect of optogenetic stimulation is still obvious. Let's look at the waveforms for the units that increase their firing rate at least 2x above baseline:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "cre_pos_units = da.unit_id[(evoked_rate / (baseline_rate + 1)) > 2].values\n", + "\n", + "plt.figure(figsize=(5,5))\n", + "\n", + "for unit_id in cre_pos_units:\n", + " \n", + " peak_channel = session.units.loc[unit_id].peak_channel_id\n", + " wv = session.mean_waveforms[unit_id].sel(channel_id = peak_channel)\n", + " \n", + " plt.plot(wv.time * 1000, wv, 'k', alpha=0.3)\n", + "\n", + "plt.xlabel('Time (ms)')\n", + "plt.ylabel('Amplitude (microvolts)')\n", + "_ =plt.plot([1.0, 1.0],[-160, 100],':c')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As expected, we see a mix of fast-spiking and regular-spiking waveforms, in contrast to the primarily fast-spiking waveforms of the Parvalbumin+ units." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, let's take a look at light-evoked activity in a VIP-Cre mouse:" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "vip_sessions = sessions[sessions.full_genotype.str.match('Vip')]\n", + "\n", + "session = cache.get_session_data(vip_sessions.index.values[-1])" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "trials = session.optogenetic_stimulation_epochs[(session.optogenetic_stimulation_epochs.duration > 0.009) & \\\n", + " (session.optogenetic_stimulation_epochs.duration < 0.02)]\n", + "\n", + "units = session.units[session.units.ecephys_structure_acronym.str.match('VIS')]\n", + "\n", + "bin_edges = np.arange(-0.01, 0.025, 0.0005)\n", + "\n", + "da = optotagging_spike_counts(bin_edges, trials, units)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_optotagging_response(da)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This response looks much different than the examples above. There is only one unit (out of more than 350 in cortex) that is obviously responding to the 10 ms light pulse. Even though the yield for VIP-Cre mice is extremely low, these units will be extremely valuable to analyze. If we can characterize the stereotypical firing patterns displayed by labeled VIP+ interneurons, we may be able to identify them in unlabeled recordings." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/doc_template/visual_coding_neuropixels.rst b/doc_template/visual_coding_neuropixels.rst index c5d15af71..71ab68ebd 100644 --- a/doc_template/visual_coding_neuropixels.rst +++ b/doc_template/visual_coding_neuropixels.rst @@ -18,6 +18,7 @@ Additional tutorials are available on the following topics: 2. `Unit quality metrics <_static/examples/nb/ecephys_quality_metrics.html>`_ `(download .ipynb) <_static/examples/nb/ecephys_quality_metrics.ipynb>`_ 3. `LFP data analysis <_static/examples/nb/ecephys_lfp_analysis.html>`_ `(download .ipynb) <_static/examples/nb/ecephys_lfp_analysis.ipynb>`_ 4. `Receptive field mapping <_static/examples/nb/ecephys_receptive_fields.html>`_ `(download .ipynb) <_static/examples/nb/ecephys_receptive_fields.ipynb>`_ + 4. `Optotagging <_static/examples/nb/ecephys_optotagging.html>`_ `(download .ipynb) <_static/examples/nb/ecephys_optotagging.ipynb>`_ For detailed information about the experimental design, data acquisition, and informatics methods, please refer to our `technical whitepaper `_. AllenSDK API documentation `is available here `_. From 43fa3655b557ecbc4db59d7b9e9c86161465c3b3 Mon Sep 17 00:00:00 2001 From: Josh Siegle Date: Thu, 20 Feb 2020 14:54:26 -0800 Subject: [PATCH 11/27] Revert ecephys_session changes --- .../examples/nb/ecephys_session.ipynb | 23 +++---------------- 1 file changed, 3 insertions(+), 20 deletions(-) diff --git a/doc_template/examples_root/examples/nb/ecephys_session.ipynb b/doc_template/examples_root/examples/nb/ecephys_session.ipynb index 8e6da1327..5777d1d7c 100644 --- a/doc_template/examples_root/examples/nb/ecephys_session.ipynb +++ b/doc_template/examples_root/examples/nb/ecephys_session.ipynb @@ -82,7 +82,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -1207,33 +1207,16 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": { "scrolled": false }, "outputs": [], "source": [ - "session_id = 732592105 # for example\n", + "session_id = 756029989 # for example\n", "session = cache.get_session_data(session_id)" ] }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "This ecephys session '732592105' has no eye tracking data. (NWB error: \"'eye_tracking' not found in modules of NWBFile 'root'\")\n" - ] - } - ], - "source": [ - "session.get_pupil_data()" - ] - }, { "cell_type": "markdown", "metadata": {}, From c3a83a92b8f48d6f0bc7a8c861ad38b178184b7a Mon Sep 17 00:00:00 2001 From: Josh Siegle Date: Thu, 20 Feb 2020 14:55:16 -0800 Subject: [PATCH 12/27] Fix list numbering --- doc_template/visual_coding_neuropixels.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc_template/visual_coding_neuropixels.rst b/doc_template/visual_coding_neuropixels.rst index 71ab68ebd..86684eeb5 100644 --- a/doc_template/visual_coding_neuropixels.rst +++ b/doc_template/visual_coding_neuropixels.rst @@ -18,7 +18,7 @@ Additional tutorials are available on the following topics: 2. `Unit quality metrics <_static/examples/nb/ecephys_quality_metrics.html>`_ `(download .ipynb) <_static/examples/nb/ecephys_quality_metrics.ipynb>`_ 3. `LFP data analysis <_static/examples/nb/ecephys_lfp_analysis.html>`_ `(download .ipynb) <_static/examples/nb/ecephys_lfp_analysis.ipynb>`_ 4. `Receptive field mapping <_static/examples/nb/ecephys_receptive_fields.html>`_ `(download .ipynb) <_static/examples/nb/ecephys_receptive_fields.ipynb>`_ - 4. `Optotagging <_static/examples/nb/ecephys_optotagging.html>`_ `(download .ipynb) <_static/examples/nb/ecephys_optotagging.ipynb>`_ + 5. `Optotagging <_static/examples/nb/ecephys_optotagging.html>`_ `(download .ipynb) <_static/examples/nb/ecephys_optotagging.ipynb>`_ For detailed information about the experimental design, data acquisition, and informatics methods, please refer to our `technical whitepaper `_. AllenSDK API documentation `is available here `_. From e6aadd732e9d5e056bc706f20f29fd356dc706d7 Mon Sep 17 00:00:00 2001 From: nile graddis Date: Fri, 21 Feb 2020 16:58:09 -0800 Subject: [PATCH 13/27] version -> 1.6.0 --- allensdk/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/allensdk/__init__.py b/allensdk/__init__.py index 732b82ba5..ad41116d0 100644 --- a/allensdk/__init__.py +++ b/allensdk/__init__.py @@ -36,7 +36,7 @@ import logging -__version__ = '1.5.0' +__version__ = '1.6.0' try: From ea8af992e136f9dbf7e19c68ec328b6f4db5c4d4 Mon Sep 17 00:00:00 2001 From: Kat Schelonka Date: Thu, 27 Feb 2020 15:38:08 -0800 Subject: [PATCH 14/27] GH 771: Remove redundant 'sham_change' column from trials --- allensdk/brain_observatory/behavior/trials_processing.py | 1 + 1 file changed, 1 insertion(+) diff --git a/allensdk/brain_observatory/behavior/trials_processing.py b/allensdk/brain_observatory/behavior/trials_processing.py index 11769fd36..f4327f494 100644 --- a/allensdk/brain_observatory/behavior/trials_processing.py +++ b/allensdk/brain_observatory/behavior/trials_processing.py @@ -345,6 +345,7 @@ def get_trials(data, licks_df, rewards_df, stimulus_presentations_df, rebase): trials = pd.DataFrame(all_trial_data).set_index('trial') trials.index = trials.index.rename('trials_id') + del trials["sham_change"] return trials From 24c0ca244212e3c855d3ea3a302bc162a7a87156 Mon Sep 17 00:00:00 2001 From: Kat Schelonka Date: Fri, 28 Feb 2020 14:15:30 -0800 Subject: [PATCH 15/27] Fix version merge artifact --- allensdk/__init__.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/allensdk/__init__.py b/allensdk/__init__.py index d4a6f22ed..ad41116d0 100644 --- a/allensdk/__init__.py +++ b/allensdk/__init__.py @@ -36,11 +36,7 @@ import logging -<<<<<<< HEAD __version__ = '1.6.0' -======= -__version__ = '1.5.1' ->>>>>>> master try: From 4b851639c5b43a7088850f7cb029cc3dc96d60b6 Mon Sep 17 00:00:00 2001 From: Kat Schelonka Date: Fri, 28 Feb 2020 15:12:02 -0800 Subject: [PATCH 16/27] GH #900: Compute display lag Previously the BehaviorOphysLimsApi did not compute monitor delay, but added a default value of 0.351. This updates the default to 0.215, which is the average of monitor delay for a large number of recent datasets. Additionally use the OphysTimeAligner methods to compute the display lag, which is used in the OphysTimeSync job to produce corrected timestamps in the LIMS pipeline. --- allensdk/internal/api/behavior_ophys_api.py | 7 +++++-- allensdk/internal/brain_observatory/time_sync.py | 2 +- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/allensdk/internal/api/behavior_ophys_api.py b/allensdk/internal/api/behavior_ophys_api.py index 53bbd5fbd..268073bc9 100644 --- a/allensdk/internal/api/behavior_ophys_api.py +++ b/allensdk/internal/api/behavior_ophys_api.py @@ -10,6 +10,7 @@ from allensdk.internal.api.ophys_lims_api import OphysLimsApi from allensdk.brain_observatory.behavior.sync import ( get_sync_data, get_stimulus_rebase_function, frame_time_offset) +from allensdk.internal.brain_observatory.time_sync import OphysTimeAligner from allensdk.brain_observatory.behavior.stimulus_processing import get_stimulus_presentations, get_stimulus_templates, get_stimulus_metadata from allensdk.brain_observatory.behavior.metadata_processing import get_task_parameters from allensdk.brain_observatory.behavior.running_processing import get_running_df @@ -38,8 +39,10 @@ def get_sync_data(self): @memoize def get_stimulus_timestamps(self): - monitor_delay = .0351 - return self.get_sync_data()['stimulus_times_no_delay'] + monitor_delay + sync_path = self.get_sync_file() + timestamps, _, _ = (OphysTimeAligner(sync_file=sync_path) + .corrected_stim_timestamps) + return timestamps @memoize def get_ophys_timestamps(self): diff --git a/allensdk/internal/brain_observatory/time_sync.py b/allensdk/internal/brain_observatory/time_sync.py index d7aa449b6..3133fb3e8 100644 --- a/allensdk/internal/brain_observatory/time_sync.py +++ b/allensdk/internal/brain_observatory/time_sync.py @@ -15,7 +15,7 @@ REG_PHOTODIODE_MAX = 2.1 # seconds PHOTODIODE_ANOMALY_THRESHOLD = 0.5 # seconds LONG_STIM_THRESHOLD = 0.2 # seconds -ASSUMED_DELAY = 0.0351 # seconds +ASSUMED_DELAY = 0.0215 # seconds MAX_MONITOR_DELAY = 0.07 # seconds VERSION_1_KEYS = { From 17bf2410c9a809b61ace0f146c12f7a28cba826d Mon Sep 17 00:00:00 2001 From: Kat Schelonka Date: Fri, 28 Feb 2020 15:14:22 -0800 Subject: [PATCH 17/27] GH #900: Compute display lag Previously the BehaviorOphysLimsApi did not compute monitor delay, but added a default value of 0.351. This updates the default to 0.215, which is the average of monitor delay for a large number of recent datasets. Additionally use the OphysTimeAligner methods to compute the display lag, which is used in the OphysTimeSync job to produce corrected timestamps in the LIMS pipeline. --- allensdk/internal/api/behavior_ophys_api.py | 7 +++++-- allensdk/internal/brain_observatory/time_sync.py | 2 +- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/allensdk/internal/api/behavior_ophys_api.py b/allensdk/internal/api/behavior_ophys_api.py index 53bbd5fbd..268073bc9 100644 --- a/allensdk/internal/api/behavior_ophys_api.py +++ b/allensdk/internal/api/behavior_ophys_api.py @@ -10,6 +10,7 @@ from allensdk.internal.api.ophys_lims_api import OphysLimsApi from allensdk.brain_observatory.behavior.sync import ( get_sync_data, get_stimulus_rebase_function, frame_time_offset) +from allensdk.internal.brain_observatory.time_sync import OphysTimeAligner from allensdk.brain_observatory.behavior.stimulus_processing import get_stimulus_presentations, get_stimulus_templates, get_stimulus_metadata from allensdk.brain_observatory.behavior.metadata_processing import get_task_parameters from allensdk.brain_observatory.behavior.running_processing import get_running_df @@ -38,8 +39,10 @@ def get_sync_data(self): @memoize def get_stimulus_timestamps(self): - monitor_delay = .0351 - return self.get_sync_data()['stimulus_times_no_delay'] + monitor_delay + sync_path = self.get_sync_file() + timestamps, _, _ = (OphysTimeAligner(sync_file=sync_path) + .corrected_stim_timestamps) + return timestamps @memoize def get_ophys_timestamps(self): diff --git a/allensdk/internal/brain_observatory/time_sync.py b/allensdk/internal/brain_observatory/time_sync.py index d7aa449b6..3133fb3e8 100644 --- a/allensdk/internal/brain_observatory/time_sync.py +++ b/allensdk/internal/brain_observatory/time_sync.py @@ -15,7 +15,7 @@ REG_PHOTODIODE_MAX = 2.1 # seconds PHOTODIODE_ANOMALY_THRESHOLD = 0.5 # seconds LONG_STIM_THRESHOLD = 0.2 # seconds -ASSUMED_DELAY = 0.0351 # seconds +ASSUMED_DELAY = 0.0215 # seconds MAX_MONITOR_DELAY = 0.07 # seconds VERSION_1_KEYS = { From 0e534257b9ca97e545e8675b01ea35d274e5da15 Mon Sep 17 00:00:00 2001 From: Kat Schelonka Date: Thu, 5 Mar 2020 12:01:22 -0800 Subject: [PATCH 18/27] GH-712: Fix auto-rewarded in rewards results Fixes a bug where auto-rewarded trials were not properly attributed in the rewards property of a visual behavior Session. Update tests to cover multiple values of 'auto_reward'. --- .../behavior/rewards_processing.py | 8 ++++---- .../behavior/test_rewards_processing.py | 17 +++++++++++------ 2 files changed, 15 insertions(+), 10 deletions(-) diff --git a/allensdk/brain_observatory/behavior/rewards_processing.py b/allensdk/brain_observatory/behavior/rewards_processing.py index 46238c396..103ce2764 100644 --- a/allensdk/brain_observatory/behavior/rewards_processing.py +++ b/allensdk/brain_observatory/behavior/rewards_processing.py @@ -3,15 +3,15 @@ def get_rewards(data, stimulus_rebase_function): - trial_df = pd.DataFrame(data["items"]["behavior"]['trial_log']) - rewards_dict = {'volume': [], 'timestamps': [], 'autorewarded': []} + trial_df = pd.DataFrame(data["items"]["behavior"]["trial_log"]) + rewards_dict = {"volume": [], "timestamps": [], "autorewarded": []} for idx, trial in trial_df.iterrows(): rewards = trial["rewards"] # as i write this there can only ever be one reward per trial if rewards: rewards_dict["volume"].append(rewards[0][0]) rewards_dict["timestamps"].append(stimulus_rebase_function(rewards[0][1])) - rewards_dict["autorewarded"].append('auto_rewarded' in trial['trial_params']) + rewards_dict["autorewarded"].append(trial["trial_params"]["auto_reward"]) - df = pd.DataFrame(rewards_dict).set_index('timestamps', drop=True) + df = pd.DataFrame(rewards_dict).set_index("timestamps", drop=True) return df diff --git a/allensdk/test/brain_observatory/behavior/test_rewards_processing.py b/allensdk/test/brain_observatory/behavior/test_rewards_processing.py index fcb7cbd68..1d7bac4ee 100644 --- a/allensdk/test/brain_observatory/behavior/test_rewards_processing.py +++ b/allensdk/test/brain_observatory/behavior/test_rewards_processing.py @@ -9,21 +9,26 @@ def test_get_rewards(): "behavior": { "trial_log": [ { - 'rewards': [(0.007, 1085.965144219165, 64775)], + 'rewards': [(0.007, 1085.96, 64775)], 'trial_params': { 'catch': False, 'auto_reward': False, 'change_time': 5}}, + { + 'rewards': [(0.007, 1090.01, 64780)], + 'trial_params': { + 'catch': False, 'auto_reward': True, + 'change_time': 6}}, { 'rewards': [], 'trial_params': { 'catch': False, 'auto_reward': False, - 'change_time': 4} - } + 'change_time': 4}, + }, ] }}} expected = pd.DataFrame( - {"volume": [0.007], - "timestamps": [1086.965144219165], - "autorewarded": False}).set_index("timestamps", drop=True) + {"volume": [0.007, 0.007], + "timestamps": [1086.96, 1091.01], + "autorewarded": [False, True]}).set_index("timestamps", drop=True) pd.testing.assert_frame_equal(expected, get_rewards(data, lambda x: x+1.0)) From e05e2ab8ff1bbf975ccd95290319b7032796e300 Mon Sep 17 00:00:00 2001 From: Kat Schelonka Date: Fri, 6 Mar 2020 13:39:09 -0800 Subject: [PATCH 19/27] GH-1404: Handle monitor delay errors If there are more "stimulus transitions" than "photodiode events", truncate the "stimulus transitions" to the number of "photodiode events". This is similar to what is done with ophys timestamps data in this module. Update test coverage to handle this case. Update logging to show the min and max delay, to help with debugging in the case of unusual/default values. --- .../internal/brain_observatory/time_sync.py | 20 +++++++++++++++---- .../brain_observatory/test_time_sync.py | 16 +++++++++++++++ 2 files changed, 32 insertions(+), 4 deletions(-) diff --git a/allensdk/internal/brain_observatory/time_sync.py b/allensdk/internal/brain_observatory/time_sync.py index 3133fb3e8..5bf16a423 100644 --- a/allensdk/internal/brain_observatory/time_sync.py +++ b/allensdk/internal/brain_observatory/time_sync.py @@ -58,11 +58,23 @@ def monitor_delay(sync_dset, stim_times, photodiode_key, """Calculate monitor delay.""" try: transitions = stim_times[::transition_frame_interval] - photodiode_events = get_real_photodiode_events(sync_dset, photodiode_key) - transition_events = photodiode_events[0:len(transitions)] + photodiode_events = get_real_photodiode_events(sync_dset, + photodiode_key) + if len(transitions) > len(photodiode_events): + logging.warning( + "More stimulus transitions counted than " + f"photodiode events (transitions={len(transitions)}, " + f"events={len(photodiode_events)}). " + "Truncating stimulus transitions to length of " + "photodiode events.") + transitions = transitions[:len(photodiode_events)] - delay = np.mean(transition_events-transitions) - logging.info("Calculated monitor delay: %s", delay) + transition_events = photodiode_events[0:len(transitions)] + delays = transition_events - transitions + delay = np.mean(delays) + logging.info(f"Calculated monitor delay: {delay}. \n " + f"Max monitor delay: {np.max(delays)}. \n " + f"Min monitor delay: {np.min(delays)}.") if delay < 0 or delay > max_monitor_delay: delay = assumed_delay diff --git a/allensdk/test/internal/brain_observatory/test_time_sync.py b/allensdk/test/internal/brain_observatory/test_time_sync.py index 46f6aeb1a..0a326630a 100644 --- a/allensdk/test/internal/brain_observatory/test_time_sync.py +++ b/allensdk/test/internal/brain_observatory/test_time_sync.py @@ -413,6 +413,22 @@ def test_module(input_json): equal_nan=True) +@pytest.mark.parametrize( + "photodiode_events,stim_events,expected_delay", + [ + (np.array([2, 3, 4, 5]), np.array([1, 2, 3, 4]), ts.ASSUMED_DELAY), + (np.array([2.02, 3.02, 4.02, 5.02]), np.array([2., 3., 4., 5.]), 0.02), + (np.array([2, 3, 4]), np.array([1, 2, 3, 4]), ts.ASSUMED_DELAY), + ] +) +def test_monitor_delay_mocked(photodiode_events, stim_events, expected_delay, + monkeypatch): + monkeypatch.setattr(ts, "get_real_photodiode_events", lambda x, y: x) + assert (ts.monitor_delay(photodiode_events, stim_events, "dummy_key", + transition_frame_interval=1) + == pytest.approx(expected_delay, 0.000001)) + + @pytest.mark.skipif(data_skip, reason="No sync or data") def test_monitor_delay(scientifica_input): sync_file = scientifica_input.pop("sync_file") From 50a2f7dfe42cf88e86637e1ce1af05be5104f022 Mon Sep 17 00:00:00 2001 From: Kat Schelonka Date: Fri, 6 Mar 2020 13:40:49 -0800 Subject: [PATCH 20/27] Revert "GH-1404: Handle monitor delay errors" This reverts commit fbadabaf795b66d00eb055881a2ec1e3c65a2968. --- .../internal/brain_observatory/time_sync.py | 20 ++++--------------- .../brain_observatory/test_time_sync.py | 16 --------------- 2 files changed, 4 insertions(+), 32 deletions(-) diff --git a/allensdk/internal/brain_observatory/time_sync.py b/allensdk/internal/brain_observatory/time_sync.py index 5bf16a423..3133fb3e8 100644 --- a/allensdk/internal/brain_observatory/time_sync.py +++ b/allensdk/internal/brain_observatory/time_sync.py @@ -58,23 +58,11 @@ def monitor_delay(sync_dset, stim_times, photodiode_key, """Calculate monitor delay.""" try: transitions = stim_times[::transition_frame_interval] - photodiode_events = get_real_photodiode_events(sync_dset, - photodiode_key) - if len(transitions) > len(photodiode_events): - logging.warning( - "More stimulus transitions counted than " - f"photodiode events (transitions={len(transitions)}, " - f"events={len(photodiode_events)}). " - "Truncating stimulus transitions to length of " - "photodiode events.") - transitions = transitions[:len(photodiode_events)] - + photodiode_events = get_real_photodiode_events(sync_dset, photodiode_key) transition_events = photodiode_events[0:len(transitions)] - delays = transition_events - transitions - delay = np.mean(delays) - logging.info(f"Calculated monitor delay: {delay}. \n " - f"Max monitor delay: {np.max(delays)}. \n " - f"Min monitor delay: {np.min(delays)}.") + + delay = np.mean(transition_events-transitions) + logging.info("Calculated monitor delay: %s", delay) if delay < 0 or delay > max_monitor_delay: delay = assumed_delay diff --git a/allensdk/test/internal/brain_observatory/test_time_sync.py b/allensdk/test/internal/brain_observatory/test_time_sync.py index 0a326630a..46f6aeb1a 100644 --- a/allensdk/test/internal/brain_observatory/test_time_sync.py +++ b/allensdk/test/internal/brain_observatory/test_time_sync.py @@ -413,22 +413,6 @@ def test_module(input_json): equal_nan=True) -@pytest.mark.parametrize( - "photodiode_events,stim_events,expected_delay", - [ - (np.array([2, 3, 4, 5]), np.array([1, 2, 3, 4]), ts.ASSUMED_DELAY), - (np.array([2.02, 3.02, 4.02, 5.02]), np.array([2., 3., 4., 5.]), 0.02), - (np.array([2, 3, 4]), np.array([1, 2, 3, 4]), ts.ASSUMED_DELAY), - ] -) -def test_monitor_delay_mocked(photodiode_events, stim_events, expected_delay, - monkeypatch): - monkeypatch.setattr(ts, "get_real_photodiode_events", lambda x, y: x) - assert (ts.monitor_delay(photodiode_events, stim_events, "dummy_key", - transition_frame_interval=1) - == pytest.approx(expected_delay, 0.000001)) - - @pytest.mark.skipif(data_skip, reason="No sync or data") def test_monitor_delay(scientifica_input): sync_file = scientifica_input.pop("sync_file") From 3f23f0f231a2d612119b275e70ab05f1bfab30c5 Mon Sep 17 00:00:00 2001 From: Kat Schelonka Date: Tue, 10 Mar 2020 12:31:22 -0700 Subject: [PATCH 21/27] GH 1411: Checksum large data in chunks. Avoids memory errors from trying to load in large data sets and generate a checksum all at once. --- .../ecephys/copy_utility/__main__.py | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/allensdk/brain_observatory/ecephys/copy_utility/__main__.py b/allensdk/brain_observatory/ecephys/copy_utility/__main__.py index 2ec28d362..6f07fbaf1 100644 --- a/allensdk/brain_observatory/ecephys/copy_utility/__main__.py +++ b/allensdk/brain_observatory/ecephys/copy_utility/__main__.py @@ -12,11 +12,17 @@ from allensdk.brain_observatory.argschema_utilities import write_or_print_outputs -def hash_file(path, hasher_cls): - with open(path, 'rb') as file_obj: - hasher = hasher_cls() - hasher.update(file_obj.read()) - return hasher.digest() +def hash_file(path, hasher_cls, blocks_per_chunk=128): + """ + + """ + hasher = hasher_cls() + with open(path, 'rb') as f: + # TODO: Update to new assignment syntax if drop < python 3.8 support + for chunk in iter( + lambda: f.read(hasher.block_size*blocks_per_chunk), b""): + hasher.update(chunk) + return hasher.digest() def walk_fs_tree(root, fn): From 057b955fd59fabbdf25f629b5fa5d9b353a277e9 Mon Sep 17 00:00:00 2001 From: isaak-willett Date: Wed, 11 Mar 2020 16:48:34 -0600 Subject: [PATCH 22/27] Added cache_spec==True keyword to lfp_writer.write call NWB advises to include this keyword in the NWB file write. This keyword caches the extension in the NWB file so it's easier for others to read data. No need to import ecephys.nwb. --- allensdk/brain_observatory/ecephys/write_nwb/__main__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/allensdk/brain_observatory/ecephys/write_nwb/__main__.py b/allensdk/brain_observatory/ecephys/write_nwb/__main__.py index ba9b21b47..0950c0d47 100644 --- a/allensdk/brain_observatory/ecephys/write_nwb/__main__.py +++ b/allensdk/brain_observatory/ecephys/write_nwb/__main__.py @@ -625,7 +625,7 @@ def write_probe_lfp_file(session_start_time, log_level, probe): with pynwb.NWBHDF5IO(probe['lfp']['output_path'], 'w') as lfp_writer: logging.info(f"writing probe lfp file to {probe['lfp']['output_path']}") - lfp_writer.write(nwbfile) + lfp_writer.write(nwbfile, cache_spec=True) return {"id": probe["id"], "nwb_path": probe["lfp"]["output_path"]} From f7b3b595c470d75cf94fa116ac6e1eefd895351f Mon Sep 17 00:00:00 2001 From: isaak-willett Date: Wed, 11 Mar 2020 16:55:19 -0600 Subject: [PATCH 23/27] Removed help from NWB file attributes No longer needed to include in the NWB file attributes. Confirmed with Ben Dichter this is not required anymore. --- .../brain_observatory/ecephys/nwb/AIBS_ecephys_extension.yaml | 4 ---- 1 file changed, 4 deletions(-) diff --git a/allensdk/brain_observatory/ecephys/nwb/AIBS_ecephys_extension.yaml b/allensdk/brain_observatory/ecephys/nwb/AIBS_ecephys_extension.yaml index 3f0c12718..ae7c47caa 100644 --- a/allensdk/brain_observatory/ecephys/nwb/AIBS_ecephys_extension.yaml +++ b/allensdk/brain_observatory/ecephys/nwb/AIBS_ecephys_extension.yaml @@ -3,10 +3,6 @@ groups: neurodata_type_inc: ElectrodeGroup doc: A group consisting of the channels on a single neuropixels probe. attributes: - - name: help - dtype: text - value: A physical grouping of channels - doc: Value is 'Metadata about a physical grouping of channels' - name: description dtype: text doc: description of this electrode group From f50680db4f32c9459c9bafba6babcf318c9718a5 Mon Sep 17 00:00:00 2001 From: Kat Schelonka Date: Fri, 7 Feb 2020 16:37:29 -0800 Subject: [PATCH 24/27] GH 1357: Project caches should not accept arbitrary kwargs Accepting arbitrary kwargs led to confusion for scientists accidentally passing incorrect keywords. This PR removes the ability to pass arbitrary kwargs to public Project cache constructors, to reduce the possibility of silent errors. --- .../behavior/behavior_project_cache.py | 102 +++++++--- .../ecephys/ecephys_project_cache.py | 183 ++++++++++++++---- .../ecephys/test_ecephys_project_cache.py | 2 +- .../Lims Behavior Project Cache.ipynb | 2 +- 4 files changed, 225 insertions(+), 64 deletions(-) diff --git a/allensdk/brain_observatory/behavior/behavior_project_cache.py b/allensdk/brain_observatory/behavior/behavior_project_cache.py index c24a3ed71..a71d62e4e 100644 --- a/allensdk/brain_observatory/behavior/behavior_project_cache.py +++ b/allensdk/brain_observatory/behavior/behavior_project_cache.py @@ -2,7 +2,8 @@ import os.path import csv from functools import partial -from typing import Type, Callable, Optional, List, Any, Dict +from typing import Type, Optional, List, Any, Dict, Union +from pathlib import Path import pandas as pd import time import logging @@ -15,8 +16,7 @@ import BehaviorProjectBase from allensdk.api.caching_utilities import one_file_call_caching, call_caching from allensdk.core.exceptions import MissingDataError -from allensdk.core.auth_config import LIMS_DB_CREDENTIAL_MAP -from allensdk.core.authentication import credential_injector, DbCredentials +from allensdk.core.authentication import DbCredentials BehaviorProjectApi = Type[BehaviorProjectBase] @@ -64,11 +64,17 @@ def __init__( self, fetch_api: Optional[BehaviorProjectApi] = None, fetch_tries: int = 2, - **kwargs): + manifest: Optional[Union[str, Path]] = None, + version: Optional[str] = None, + cache: bool = True): """ Entrypoint for accessing visual behavior data. Supports access to summaries of session data and provides tools for downloading detailed session data (such as dff traces). + Likely you will want to use a class constructor, such as `from_lims`, + to initialize a BehaviorProjectCache, rather than calling this + directly. + --- NOTE --- Because NWB files are not currently supported for this project (as of 11/2019), this cache will not actually save any files of session data @@ -87,38 +93,88 @@ def __init__( Used to pull data from remote sources, after which it is locally cached. Any object inheriting from BehaviorProjectBase is suitable. Current options are: - EcephysProjectLimsApi :: Fetches bleeding-edge data from the + BehaviorProjectLimsApi :: Fetches bleeding-edge data from the Allen Institute"s internal database. Only works if you are on our internal network. fetch_tries : Maximum number of times to attempt a download before giving up and - raising an exception. Note that this is total tries, not retries - **kwargs : - manifest : str or Path - full path at which manifest json will be stored - version : str - version of manifest file. If this mismatches the version - recorded in the file at manifest, an error will be raised. - other kwargs are passed to allensdk.api.cache.Cache + raising an exception. Note that this is total tries, not retries. + Default=2. + manifest : str or Path + full path at which manifest json will be stored. Defaults + to "behavior_project_manifest.json" in the local directory. + version : str + version of manifest file. If this mismatches the version + recorded in the file at manifest, an error will be raised. + Defaults to the manifest version in the class. + cache : bool + Whether to write to the cache. Default=True. """ - kwargs["manifest"] = kwargs.get("manifest", - "behavior_project_manifest.json") - kwargs["version"] = kwargs.get("version", self.MANIFEST_VERSION) + manifest_ = manifest or "behavior_project_manifest.json" + version_ = version or self.MANIFEST_VERSION - super().__init__(**kwargs) - self.fetch_api = fetch_api or BehaviorProjectLimsApi.default() + super().__init__(manifest=manifest_, version=version_, cache=cache) + self.fetch_api = fetch_api self.fetch_tries = fetch_tries self.logger = logging.getLogger(self.__class__.__name__) @classmethod - def from_lims(cls, lims_credentials: Optional[DbCredentials] = None, + def from_lims(cls, manifest: Optional[Union[str, Path]] = None, + version: Optional[str] = None, + cache: bool = True, + fetch_tries: int = 2, + lims_credentials: Optional[DbCredentials] = None, mtrain_credentials: Optional[DbCredentials] = None, - app_kwargs: Dict[str, Any] = None, **kwargs): - return cls(fetch_api=BehaviorProjectLimsApi.default( + host: Optional[str] = None, + scheme: Optional[str] = None, + asynchronous: Optional[str] = None) -> "BehaviorProjectCache": + """ + Construct a BehaviorProjectCache with a lims api. Use this method + to create a BehaviorProjectCache instance rather than calling + BehaviorProjectCache directly. + + Parameters + ========== + manifest : str or Path + full path at which manifest json will be stored + version : str + version of manifest file. If this mismatches the version + recorded in the file at manifest, an error will be raised. + cache : bool + Whether to write to the cache + fetch_tries : int + Maximum number of times to attempt a download before giving up and + raising an exception. Note that this is total tries, not retries + lims_credentials : DbCredentials + Optional credentials to access LIMS database. + If not set, will look for credentials in environment variables. + mtrain_credentials: DbCredentials + Optional credentials to access mtrain database. + If not set, will look for credentials in environment variables. + host : str + Web host for the app_engine. Currently unused. This argument is + included for consistency with EcephysProjectCache.from_lims. + scheme : str + URI scheme, such as "http". Currently unused. This argument is + included for consistency with EcephysProjectCache.from_lims. + asynchronous : bool + Whether to fetch from web asynchronously. Currently unused. + Returns + ======= + BehaviorProjectCache + BehaviorProjectCache instance with a LIMS fetch API + """ + if host and scheme: + app_kwargs = {"host": host, "scheme": scheme, + "asynchronous": asynchronous} + else: + app_kwargs = None + fetch_api = BehaviorProjectLimsApi.default( lims_credentials=lims_credentials, mtrain_credentials=mtrain_credentials, - app_kwargs=app_kwargs), - **kwargs) + app_kwargs=app_kwargs) + return cls(fetch_api=fetch_api, manifest=manifest, version=version, + cache=cache, fetch_tries=fetch_tries) def get_session_table( self, diff --git a/allensdk/brain_observatory/ecephys/ecephys_project_cache.py b/allensdk/brain_observatory/ecephys/ecephys_project_cache.py index e615ced9f..61cf084d0 100644 --- a/allensdk/brain_observatory/ecephys/ecephys_project_cache.py +++ b/allensdk/brain_observatory/ecephys/ecephys_project_cache.py @@ -1,6 +1,6 @@ from functools import partial from pathlib import Path -from typing import Any, List, Optional +from typing import Any, List, Optional, Union, Callable import ast import pandas as pd @@ -9,13 +9,13 @@ import pynwb from allensdk.api.cache import Cache - +from allensdk.core.authentication import DbCredentials from allensdk.brain_observatory.ecephys.ecephys_project_api import ( EcephysProjectApi, EcephysProjectLimsApi, EcephysProjectWarehouseApi, EcephysProjectFixedApi ) from allensdk.brain_observatory.ecephys.ecephys_project_api.rma_engine import ( - AsyncRmaEngine, + AsyncRmaEngine, RmaEngine ) from allensdk.brain_observatory.ecephys.ecephys_project_api.http_engine import ( write_bytes_from_coroutine, write_from_stream @@ -27,7 +27,6 @@ from allensdk.brain_observatory.ecephys import get_unit_filter_value from allensdk.api.caching_utilities import one_file_call_caching - class EcephysProjectCache(Cache): SESSIONS_KEY = 'sessions' @@ -74,11 +73,13 @@ class EcephysProjectCache(Cache): ) def __init__( - self, - fetch_api: EcephysProjectApi = EcephysProjectWarehouseApi.default(), - fetch_tries: int = 2, - stream_writer = write_from_stream, - **kwargs): + self, + fetch_api: EcephysProjectApi = EcephysProjectWarehouseApi.default(), + fetch_tries: int = 2, + stream_writer: Callable = write_from_stream, + manifest: Optional[Union[str, Path]] = None, + version: Optional[str] = None, + cache: bool = True): """ Entrypoint for accessing ecephys (neuropixels) data. Supports access to cross-session data (like stimulus templates) and high-level summaries of sessionwise data and provides tools for downloading detailed @@ -88,33 +89,34 @@ def __init__( ========== fetch_api : Used to pull data from remote sources, after which it is locally - cached. Any object exposing the EcephysProjectApi interface is + cached. Any object exposing the EcephysProjectApi interface is suitable. Standard options are: - EcephysProjectWarehouseApi :: The default. Fetches publically + EcephysProjectWarehouseApi :: The default. Fetches publically available Allen Institute data - EcephysProjectFixedApi :: Refuses to fetch any data - only the - existing local cache is accessible. Useful if you want to - settle on a fixed dataset for analysis. - EcephysProjectLimsApi :: Fetches bleeding-edge data from the - Allen Institute's internal database. Only works if you are + EcephysProjectFixedApi :: Refuses to fetch any data - only the + existing local cache is accessible. Useful if you want to + settle on a fixed dataset for analysis + EcephysProjectLimsApi :: Fetches bleeding-edge data from the + Allen Institute's internal database. Only works if you are on our internal network. - fetch_tries : - Maximum number of times to attempt a download before giving up and + fetch_tries : int + Maximum number of times to attempt a download before giving up and raising an exception. Note that this is total tries, not retries - **kwargs : - manifest : str or Path - full path at which manifest json will be stored - version : str - version of manifest file. If this mismatches the version - recorded in the file at manifest, an error will be raised. - other kwargs are passed to allensdk.api.cache.Cache - + manifest : str or Path + full path at which manifest json will be stored (default = + "ecephys_project_manifest.json" in the local directory.) + version : str + version of manifest file. If this mismatches the version + recorded in the file at manifest, an error will be raised. + cache: bool + Whether to write to the cache (default=True) """ + manifest_ = manifest or "ecephys_project_manifest.json" + version_ = version or self.MANIFEST_VERSION - kwargs['manifest'] = kwargs.get('manifest', 'ecephys_project_manifest.json') - kwargs['version'] = kwargs.get('version', self.MANIFEST_VERSION) - - super(EcephysProjectCache, self).__init__(**kwargs) + super(EcephysProjectCache, self).__init__(manifest=manifest_, + version=version_, + cache=cache) self.fetch_api = fetch_api self.fetch_tries = fetch_tries self.stream_writer = stream_writer @@ -516,7 +518,7 @@ def _from_http_source_default(cls, fetch_api_cls, fetch_api_kwargs, **kwargs): "asynchronous": True } if fetch_api_kwargs is None else fetch_api_kwargs - if "stream_writer" not in kwargs: + if kwargs.get("stream_writer") is None: if fetch_api_kwargs.get("asynchronous", True): kwargs["stream_writer"] = write_bytes_from_coroutine else: @@ -528,21 +530,124 @@ def _from_http_source_default(cls, fetch_api_cls, fetch_api_kwargs, **kwargs): ) @classmethod - def from_lims(cls, lims_kwargs=None, **kwargs): + def from_lims(cls, lims_credentials: Optional[DbCredentials] = None, + scheme: Optional[str] = None, + host: Optional[str] = None, + asynchronous: bool = True, + manifest: Optional[str] = None, + version: Optional[str] = None, + cache: bool = True, + fetch_tries: int = 2): + """ + Create an instance of EcephysProjectCache with an + EcephysProjectLimsApi. Retrieves bleeding-edge data stored + locally on Allen Institute servers. Only available for use + on-site at the Allen Institute or through a vpn. Requires Allen + Institute database credentials. + + Parameters + ========== + lims_credentials : DbCredentials + Credentials to access LIMS database. If not provided will + attempt to find credentials in environment variables. + scheme : str + URI scheme, such as "http". Defaults to + EcephysProjectLimsApi.default value if unspecified. + Will not be used unless `host` is also specified. + host : str + Web host. Defaults to EcephysProjectLimsApi.default + value if unspecified. Will not be used unless `scheme` is + also specified. + asynchronous : bool + Whether to fetch file asynchronously. Defaults to True. + manifest : str or Path + full path at which manifest json will be stored + version : str + version of manifest file. If this mismatches the version + recorded in the file at manifest, an error will be raised. + cache: bool + Whether to write to the cache (default=True) + fetch_tries : int + Maximum number of times to attempt a download before giving up and + raising an exception. Note that this is total tries, not retries + """ + if scheme and host: + app_kwargs = {"scheme": scheme, "host": host} + else: + app_kwargs = None return cls._from_http_source_default( - EcephysProjectLimsApi, lims_kwargs, **kwargs - ) + EcephysProjectLimsApi, + {"lims_credentials": lims_credentials, + "app_kwargs": app_kwargs, + "asynchronous": asynchronous, + }, # expects dictionary of kwargs + manifest=manifest, version=version, cache=cache, + fetch_tries=fetch_tries) @classmethod - def from_warehouse(cls, warehouse_kwargs=None, **kwargs): + def from_warehouse(cls, + scheme: Optional[str] = None, + host: Optional[str] = None, + asynchronous: bool = True, + manifest: Optional[Union[str, Path]] = None, + version: Optional[str] = None, + cache: bool = True, + fetch_tries: int = 2): + """ + Create an instance of EcephysProjectCache with an + EcephysProjectWarehouseApi. Retrieves released data stored in + the warehouse. + + Parameters + ========== + scheme : str + URI scheme, such as "http". Defaults to + EcephysProjectWarehouseAPI.default value if unspecified. + Will not be used unless `host` is also specified. + host : str + Web host. Defaults to EcephysProjectWarehouseApi.default + value if unspecified. Will not be used unless `scheme` is also + specified. + asynchronous : bool + Whether to fetch file asynchronously. Defaults to True. + manifest : str or Path + full path at which manifest json will be stored + version : str + version of manifest file. If this mismatches the version + recorded in the file at manifest, an error will be raised. + cache: bool + Whether to write to the cache (default=True) + fetch_tries : int + Maximum number of times to attempt a download before giving up and + raising an exception. Note that this is total tries, not retries + """ + if scheme and host: + app_kwargs = {"scheme": scheme, "host": host, + "asynchronous": asynchronous} + else: + app_kwargs = None return cls._from_http_source_default( - EcephysProjectWarehouseApi, warehouse_kwargs, **kwargs + EcephysProjectWarehouseApi, app_kwargs, manifest=manifest, + version=version, cache=cache, fetch_tries=fetch_tries ) - @classmethod - def fixed(cls, **kwargs): - return cls(fetch_api=EcephysProjectFixedApi(), **kwargs) + def fixed(cls, manifest=None, version=None): + """ + Creates a EcephysProjectCache that refuses to fetch any data + - only the existing local cache is accessible. Useful if you + want to settle on a fixed dataset for analysis. + + Parameters + ========== + manifest : str or Path + full path to existing manifest json + version : str + version of manifest file. If this mismatches the version + recorded in the file at manifest, an error will be raised. + """ + return cls(fetch_api=EcephysProjectFixedApi(), manifest=manifest, + version=version) def count_owned(this, other, foreign_key, count_key, inplace=False): diff --git a/allensdk/test/brain_observatory/ecephys/test_ecephys_project_cache.py b/allensdk/test/brain_observatory/ecephys/test_ecephys_project_cache.py index 85c56992d..6ff10a082 100644 --- a/allensdk/test/brain_observatory/ecephys/test_ecephys_project_cache.py +++ b/allensdk/test/brain_observatory/ecephys/test_ecephys_project_cache.py @@ -373,7 +373,7 @@ def test_from_lims_default(tmpdir_factory): tmpdir = str(tmpdir_factory.mktemp("test_from_lims_default")) cache = epc.EcephysProjectCache.from_lims( - manifest_path=os.path.join(tmpdir, "manifest.json") + manifest=os.path.join(tmpdir, "manifest.json") ) assert isinstance(cache.fetch_api.app_engine, AsyncHttpEngine) assert cache.stream_writer is epc.write_bytes_from_coroutine \ No newline at end of file diff --git a/doc_template/examples_root/examples/internal/Lims Behavior Project Cache.ipynb b/doc_template/examples_root/examples/internal/Lims Behavior Project Cache.ipynb index b6228fd06..ef9348104 100644 --- a/doc_template/examples_root/examples/internal/Lims Behavior Project Cache.ipynb +++ b/doc_template/examples_root/examples/internal/Lims Behavior Project Cache.ipynb @@ -892,7 +892,7 @@ ], "source": [ "# But it will work if we use one that already exists\n", - "cache.get_session_data(978244684, fixed=True)" + "cache.get_session_data(latest.name, fixed=True)" ] }, { From 43508285b2cfbc220d2e8db8499ff3bc6a2e9c82 Mon Sep 17 00:00:00 2001 From: Kat Schelonka Date: Fri, 13 Mar 2020 09:47:47 -0700 Subject: [PATCH 25/27] Remove unnecessary imports and update asynchronous type in BehaviorProjectCache --- .../brain_observatory/behavior/behavior_project_cache.py | 2 +- allensdk/brain_observatory/ecephys/ecephys_project_cache.py | 6 ++---- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/allensdk/brain_observatory/behavior/behavior_project_cache.py b/allensdk/brain_observatory/behavior/behavior_project_cache.py index a71d62e4e..15f305759 100644 --- a/allensdk/brain_observatory/behavior/behavior_project_cache.py +++ b/allensdk/brain_observatory/behavior/behavior_project_cache.py @@ -127,7 +127,7 @@ def from_lims(cls, manifest: Optional[Union[str, Path]] = None, mtrain_credentials: Optional[DbCredentials] = None, host: Optional[str] = None, scheme: Optional[str] = None, - asynchronous: Optional[str] = None) -> "BehaviorProjectCache": + asynchronous: bool = True) -> "BehaviorProjectCache": """ Construct a BehaviorProjectCache with a lims api. Use this method to create a BehaviorProjectCache instance rather than calling diff --git a/allensdk/brain_observatory/ecephys/ecephys_project_cache.py b/allensdk/brain_observatory/ecephys/ecephys_project_cache.py index 61cf084d0..e8d7d23b5 100644 --- a/allensdk/brain_observatory/ecephys/ecephys_project_cache.py +++ b/allensdk/brain_observatory/ecephys/ecephys_project_cache.py @@ -11,12 +11,9 @@ from allensdk.api.cache import Cache from allensdk.core.authentication import DbCredentials from allensdk.brain_observatory.ecephys.ecephys_project_api import ( - EcephysProjectApi, EcephysProjectLimsApi, EcephysProjectWarehouseApi, + EcephysProjectApi, EcephysProjectLimsApi, EcephysProjectWarehouseApi, EcephysProjectFixedApi ) -from allensdk.brain_observatory.ecephys.ecephys_project_api.rma_engine import ( - AsyncRmaEngine, RmaEngine -) from allensdk.brain_observatory.ecephys.ecephys_project_api.http_engine import ( write_bytes_from_coroutine, write_from_stream ) @@ -27,6 +24,7 @@ from allensdk.brain_observatory.ecephys import get_unit_filter_value from allensdk.api.caching_utilities import one_file_call_caching + class EcephysProjectCache(Cache): SESSIONS_KEY = 'sessions' From e006d3e0884df782ac49b03e98412a6d0358e4c8 Mon Sep 17 00:00:00 2001 From: Dan Date: Mon, 23 Mar 2020 14:01:21 -0700 Subject: [PATCH 26/27] updating to keyword density from normed for matplotlib.pyplot.hist --- allensdk/brain_observatory/observatory_plots.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/allensdk/brain_observatory/observatory_plots.py b/allensdk/brain_observatory/observatory_plots.py index cefeb7f83..25ef1a834 100644 --- a/allensdk/brain_observatory/observatory_plots.py +++ b/allensdk/brain_observatory/observatory_plots.py @@ -260,7 +260,7 @@ def plot_condition_histogram(vals, bins, color=STIM_COLOR): n, hbins, patches = plt.hist(vals, bins=np.arange(len(bins)+1)+1, align='left', - normed=False, + density=False, rwidth=.8, color=color, zorder=3) @@ -287,7 +287,7 @@ def plot_selectivity_cumulative_histogram(sis, # orientation selectivity cumulative histogram if len(sis) > 0: - n, bins, patches = plt.hist(sis, normed=True, bins=bins, + n, bins, patches = plt.hist(sis, density=True, bins=bins, cumulative=True, histtype='stepfilled', color=color) plt.xlim(si_range) From 4f873c49ef4b93d838492b1bd6bd822bcff0e56b Mon Sep 17 00:00:00 2001 From: Dan Date: Mon, 23 Mar 2020 15:56:34 -0700 Subject: [PATCH 27/27] update what's new and changelog --- CHANGELOG.md | 18 ++++++++++++++++++ doc_template/index.rst | 22 +++++++++++++--------- 2 files changed, 31 insertions(+), 9 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index ab3c52e05..416dce683 100755 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,24 @@ # Change Log All notable changes to this project will be documented in this file. +## [1.6.0] = 2020-03-23 + +### Added +- tutorial for optotagging for ecephys notebook +- get\_receptive\_field() method in ecephys receptive field mapping + +### Changed +- remove redundant sham\_change column in behavior sessions.trials table +- versions for NWB output for ecephys and ophys behavior. +- monitor delay is now calculated for BehaviorOphysLimsApi rather than defaulting to 0.0351 + +### Bug Fixes +- Fixed a bug where auto-rewarded trials were not properly attributed in the rewards property of a visual behavior +- return None rather than raise exception if no container id was returned from lims id for given ophys id +- Project caches no longer accept arbitrary keywords +- matplotloib.pyplot.hist parameter normed no longer supported + + ## [1.5.0] = 2020-02-10 ### Added diff --git a/doc_template/index.rst b/doc_template/index.rst index 45ea05c74..42ec9c28a 100644 --- a/doc_template/index.rst +++ b/doc_template/index.rst @@ -90,6 +90,18 @@ The Allen SDK provides Python code for accessing experimental metadata along wit See the `mouse connectivity section `_ for more details. +What's New - 1.6.0 (March 23, 2020) +----------------------------------------------------------------------- + +As of the 1.6.0 release: + +- added get_receptive_field alias() for _get_rf() in allensdk/brain_observatory/ecephys/stimulus_analysis/receptive_field_mapping.py +- Added required version to namespace and caches spec in ecephy nwb outputs in allensdk/brain_observatory/ecephys/nwb/AIBS_ecephys_namespace.yaml +- Added version for ophys behavior nwb output to allensdk/brain_observatory/nwb/AIBS_ophys_behavior_namespace.yaml +- Behavior and ECEphys project caches no longer accept arbitrary keywords to prevent confusion when user supplies incorrect kwargs to constructor. +- New ecephys notebook for optotagging tutorial. + + What's New - 1.5.0 (February 10, 2020) ----------------------------------------------------------------------- @@ -101,17 +113,9 @@ As of the 1.5.0 release: - morphology.apply_affine correctly rescales radii -What's New - 1.4.0 (January 23, 2020) ------------------------------------------------------------------------ - -As of the 1.4.0 release: - -- users of the ephys extractor can supply their own cutoff frequency for low-pass bessel filter. -- (internal feature) the ophys time sync module writes an output json describing its results. - - Previous Release Notes ---------------------- + * `1.4.0 `_ * `1.3.0 `_ * `1.2.0 `_ * `1.1.1 `_