{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "- Extract data from spike2 recordings (in the HDF5 format):\n", " - frame-to-frame intervals\n", " - exposure-to-trigger latency\n", "- output in a HDF file." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from pathlib import Path\n", "from collections import namedtuple\n", "import h5py\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "%matplotlib inline" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "def split_epochs(flags, min_interval=500):\n", " indexes = np.where(flags)[0]\n", " start = indexes[0]\n", " stop = indexes[1]\n", " offset = 2\n", " while offset < indexes.size:\n", " next_stop = indexes[offset]\n", " if next_stop - stop > min_interval:\n", " yield slice(start, stop+1)\n", " start = next_stop\n", " stop = indexes[offset + 1]\n", " offset += 2\n", " else:\n", " stop = next_stop\n", " offset += 1\n", " yield slice(start, flags.size)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "srcroot = Path(\"../../Spike2Recordings/\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Overview of a source file (training period)\n", "\n", "I did not separate the file with acquisition.\n", "\n", "So it is necessary first to split the recordings based on the duration of acquisition." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'SNA-079260_2020-12-06-train_spike2_run001.h5'" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "src_sess = srcroot / \"SNA-079260\" / \"2020-12-06-train\"\n", "srcpath = sorted(src_sess.glob(\"*.h5\"))[0]\n", "srcpath.name" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "with h5py.File(str(srcpath), \"r\") as src:\n", " subject = src.attrs[\"subject\"]\n", " session = src.attrs[\"session\"]\n", " run = src.attrs[\"run\"]\n", " time = np.array(src[\"time\"])\n", " camera_raw = np.array(src[\"exposure\"])\n", " trigger_raw = np.array(src[\"trigger\"])" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0.5, 1.0, 'SNA-079260, session 2020-12-06-train, run 001')" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fig, axes = plt.subplots(2,1,sharex=True,figsize=(8,2))\n", "axes[0].plot(time, camera_raw, lw=1)\n", "axes[1].plot(time, trigger_raw, lw=1)\n", "axes[0].set_title(f\"{subject}, session {session}, run {run}\")" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "frame_start = np.diff((camera_raw < 2).astype(int)) == 1\n", "triggered = np.where(trigger_raw > 2)[0]\n", "\n", "triggered.size # no value" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(time[:-1], frame_start)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "for epoch in split_epochs(frame_start):\n", " plt.plot(time[epoch], frame_start[epoch], lw=1)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "class LatencyDescription(namedtuple(\"_Latency\", (\"subject\", \"session\", \"run\", \"epoch\",\n", " \"frame_intervals\"))):\n", " @classmethod\n", " def from_file(cls, path):\n", " with h5py.File(str(path), \"r\") as src:\n", " subject = src.attrs[\"subject\"]\n", " session = src.attrs[\"session\"]\n", " run = src.attrs[\"run\"]\n", " time = np.array(src[\"time\"])\n", " camera_raw = np.array(src[\"exposure\"])\n", " frame_start = np.diff((camera_raw < 2).astype(int)) == 1\n", " out = []\n", " for i, epoch in enumerate(split_epochs(frame_start), start=1):\n", " out.append(cls(subject, session, run, str(i).zfill(3),\n", " np.diff(np.where(frame_start[epoch])[0])))\n", " return tuple(out)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "intervals = LatencyDescription.from_file(srcpath)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "LatencyDescription(subject='SNA-079260', session='2020-12-06-train', run='001', epoch='001', frame_intervals=array([ 28, 98, 100, ..., 100, 100, 100]))" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "intervals[0]" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "_ = plt.hist(intervals[0].frame_intervals, bins=100, range=(0, 200))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Overview of a source file (test period)\n", "\n", "Need to check whether the trigger is enabled" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'SNA-079258_2020-12-06-test_spike2_run001.h5'" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "src_sess = srcroot / \"SNA-079258\" / \"2020-12-06-test\"\n", "srcpath = sorted(src_sess.glob(\"*.h5\"))[0]\n", "srcpath.name" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "33486" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "with h5py.File(str(srcpath), \"r\") as src:\n", " subject = src.attrs[\"subject\"]\n", " session = src.attrs[\"session\"]\n", " run = src.attrs[\"run\"]\n", " time = np.array(src[\"time\"])\n", " camera_raw = np.array(src[\"exposure\"])\n", " trigger_raw = np.array(src[\"trigger\"])\n", " \n", "frame_start = np.diff((camera_raw < 2).astype(int)) == 1\n", "triggered = trigger_raw > 2\n", "\n", "np.count_nonzero(triggered)" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "trigger_on = np.where(np.diff(triggered.astype(int)) == 1)[0] + 1\n", "\n", "# calculate trigger latency (in samples)\n", "latency = np.empty(trigger_on.size, dtype=np.int64)\n", "MAX_LAT = 500 # 50 ms\n", "for i, _index in enumerate(trigger_on):\n", " _start = max(0, _index - MAX_LAT)\n", " _frames = np.where(frame_start[_start:_index])[0]\n", " if _frames.size > 0:\n", " _latency = _index - (_start + _frames.max())\n", " else:\n", " _latency = np.inf\n", " latency[i] = _latency" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 94, 149, 144, 108, 103, 95, 107, 97, 97, 101, 96, 101, 95,\n", " 95, 96, 103, 94, 4, 95, 101, 100, 114, 104, 105, 103, 107,\n", " 96, 96, 107, 104, 99, 104, 104, 96, 112, 98, 98, 97, 106,\n", " 110, 102, 98, 98, 110, 97, 95, 96, 106, 104, 104, 105, 98,\n", " 101, 95, 119, 100, 97, 114, 98, 107, 103, 97, 101, 129, 164,\n", " 164, 166, 170, 172, 136, 110, 104, 94, 200, 216, 104, 129, 106,\n", " 96, 98, 96, 96, 97, 104, 113, 97, 95, 96, 99, 105, 98,\n", " 104, 109, 106, 108, 107, 138, 162, 95, 111, 135, 97, 111, 97,\n", " 98, 103, 97, 98, 97, 115, 105, 97, 96, 138, 138, 144, 95,\n", " 104, 142, 163, 132, 96, 94, 97, 96, 131, 98, 96, 96, 108,\n", " 97, 112, 148, 171, 100, 105])" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "latency" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [], "source": [ "def calc_latency(frame_start, triggered, max_latency=500, outlier=-1):\n", " trigger_on = np.where(np.diff(triggered.astype(int)) == 1)[0] + 1\n", " trigger_off = np.where(np.diff(triggered.astype(int)) == -1)[0] + 1\n", " \n", " out = []\n", " for trigger in (trigger_on, trigger_off):\n", " latency = np.empty(trigger.size, dtype=np.int64)\n", " for i, _index in enumerate(trigger):\n", " _start = max(0, _index - max_latency)\n", " _frames = np.where(frame_start[_start:_index])[0]\n", " if _frames.size > 0:\n", " _latency = _index - (_start + _frames.max())\n", " else:\n", " _latency = outlier\n", " latency[i] = _latency\n", " out.append(latency)\n", " return tuple(out)" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(array([ 94, 149, 144, 108, 103, 95, 107, 97, 97, 101, 96, 101, 95,\n", " 95, 96, 103, 94, 4, 95, 101, 100, 114, 104, 105, 103, 107,\n", " 96, 96, 107, 104, 99, 104, 104, 96, 112, 98, 98, 97, 106,\n", " 110, 102, 98, 98, 110, 97, 95, 96, 106, 104, 104, 105, 98,\n", " 101, 95, 119, 100, 97, 114, 98, 107, 103, 97, 101, 129, 164,\n", " 164, 166, 170, 172, 136, 110, 104, 94, 200, 216, 104, 129, 106,\n", " 96, 98, 96, 96, 97, 104, 113, 97, 95, 96, 99, 105, 98,\n", " 104, 109, 106, 108, 107, 138, 162, 95, 111, 135, 97, 111, 97,\n", " 98, 103, 97, 98, 97, 115, 105, 97, 96, 138, 138, 144, 95,\n", " 104, 142, 163, 132, 96, 94, 97, 96, 131, 98, 96, 96, 108,\n", " 97, 112, 148, 171, 100, 105]),\n", " array([ 94, 148, 145, 99, 94, 95, 104, 103, 101, 104, 95, 95, 102,\n", " 104, 102, 95, 3, 95, 105, 95, 105, 101, 95, 97, 103, 102,\n", " 97, 99, 114, 98, 120, 97, 98, 104, 95, 97, 94, 95, 102,\n", " 96, 95, 100, 98, 94, 141, 95, 107, 97, 97, 95, 101, 104,\n", " 94, 97, 97, 96, 106, 105, 102, 98, 97, 116, 101, 162, 164,\n", " 165, 169, 174, 162, 108, 114, 105, 121, 201, 95, 102, 104, 119,\n", " 95, 97, 105, 95, 98, 104, 96, 97, 97, 102, 106, 97, 104,\n", " 96, 113, 97, 96, 121, 94, 162, 108, 130, 95, 103, 112, 104,\n", " 98, 96, 103, 95, 107, 134, 121, 110, 95, 137, 142, 143, 107,\n", " 97, 165, 164, 111, 96, 101, 95, 105, 203, 96, 104, 104, 106,\n", " 97, 114, 150, 176, 96, 107]))" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "calc_latency(frame_start, triggered)" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "class LatencyDescription(namedtuple(\"_Latency\", (\"subject\", \"session\", \"run\", \"epoch\", \"has_trigger\",\n", " \"frame_intervals\", \"on_latency\", \"off_latency\"))):\n", " @classmethod\n", " def from_file(cls, path):\n", " with h5py.File(str(path), \"r\") as src:\n", " subject = src.attrs[\"subject\"]\n", " session = src.attrs[\"session\"]\n", " run = src.attrs[\"run\"]\n", " time = np.array(src[\"time\"])\n", " camera_raw = np.array(src[\"exposure\"])\n", " trigger_raw = np.array(src[\"trigger\"])\n", " frame_start = np.diff((camera_raw < 2).astype(int)) == 1\n", " triggered = trigger_raw > 2\n", " \n", " out = []\n", " for i, epoch in enumerate(split_epochs(frame_start), start=1):\n", " _frame = frame_start[epoch]\n", " _trig = triggered[epoch]\n", " _intervals = np.diff(np.where(_frame)[0])\n", " if np.count_nonzero(_trig) > 0:\n", " _has_trig = True\n", " _on_lat, _off_lat = calc_latency(_frame, _trig)\n", " else:\n", " _has_trig = False\n", " _on_lat, _off_lat = None, None\n", " out.append(cls(subject, session, run, str(i).zfill(3), _has_trig,\n", " _intervals, _on_lat, _off_lat))\n", " return tuple(out)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "lat = LatencyDescription.from_file(srcpath)" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(LatencyDescription(subject='SNA-079258', session='2020-12-06-train', run='001', epoch='001', has_trigger=True, frame_intervals=array([166, 128, 120, ..., 100, 112, 108]), on_latency=array([ 94, 149, 144, 108, 103, 95, 107, 97, 97, 101, 96, 101, 95,\n", " 95, 96, 103, 94, 4, 95, 101, 100, 114, 104, 105, 103, 107,\n", " 96, 96, 107, 104, 99, 104, 104, 96, 112, 98, 98, 97, 106,\n", " 110, 102, 98, 98, 110, 97, 95, 96, 106, 104, 104, 105, 98,\n", " 101, 95, 119, 100, 97, 114, 98, 107, 103, 97, 101, 129, 164,\n", " 164, 166, 170, 172, 136, 110, 104, 94, 200, 216, 104, 129, 106,\n", " 96, 98, 96, 96, 97, 104, 113, 97, 95, 96, 99, 105, 98,\n", " 104, 109, 106, 108, 107, 138, 162, 95, 111, 135, 97, 111, 97,\n", " 98, 103, 97, 98, 97, 115, 105, 97, 96, 138, 138, 144, 95,\n", " 104, 142, 163, 132, 96, 94, 97, 96, 131, 98, 96, 96, 108,\n", " 97, 112, 148, 171, 100, 105]), off_latency=array([ 94, 148, 145, 99, 94, 95, 104, 103, 101, 104, 95, 95, 102,\n", " 104, 102, 95, 3, 95, 105, 95, 105, 101, 95, 97, 103, 102,\n", " 97, 99, 114, 98, 120, 97, 98, 104, 95, 97, 94, 95, 102,\n", " 96, 95, 100, 98, 94, 141, 95, 107, 97, 97, 95, 101, 104,\n", " 94, 97, 97, 96, 106, 105, 102, 98, 97, 116, 101, 162, 164,\n", " 165, 169, 174, 162, 108, 114, 105, 121, 201, 95, 102, 104, 119,\n", " 95, 97, 105, 95, 98, 104, 96, 97, 97, 102, 106, 97, 104,\n", " 96, 113, 97, 96, 121, 94, 162, 108, 130, 95, 103, 112, 104,\n", " 98, 96, 103, 95, 107, 134, 121, 110, 95, 137, 142, 143, 107,\n", " 97, 165, 164, 111, 96, 101, 95, 105, 203, 96, 104, 104, 106,\n", " 97, 114, 150, 176, 96, 107])),)" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "lat" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "reading: SNA-079258_2020-12-04-train_spike2_run001.h5... done.\n", "reading: SNA-079258_2020-12-04-train_spike2_run002.h5... done.\n", "reading: SNA-079258_2020-12-04-train_spike2_run003.h5... done.\n", "reading: SNA-079258_2020-12-06-test_spike2_run001.h5... done.\n", "reading: SNA-079258_2020-12-06-test_spike2_run002.h5... done.\n", "reading: SNA-079258_2020-12-06-test_spike2_run003.h5... done.\n", "reading: SNA-079258_2020-12-06-test_spike2_run004.h5... done.\n", "reading: SNA-079258_2020-12-06-test_spike2_run005.h5... done.\n", "reading: SNA-079258_2020-12-07-test_spike2_run001.h5... done.\n", "reading: SNA-079258_2020-12-07-test_spike2_run002.h5... done.\n", "reading: SNA-079258_2020-12-07-test_spike2_run003.h5... done.\n", "reading: SNA-079258_2020-12-07-test_spike2_run004.h5... done.\n", "reading: SNA-079258_2020-12-11-test_spike2_run001.h5... done.\n", "reading: SNA-079258_2020-12-11-test_spike2_run002.h5... done.\n", "reading: SNA-079258_2020-12-11-test_spike2_run003.h5... done.\n", "reading: SNA-079259_2020-12-06-train_spike2_run001.h5... done.\n", "reading: SNA-079259_2020-12-11-test_spike2_run001.h5... done.\n", "reading: SNA-079259_2020-12-11-test_spike2_run002.h5... done.\n", "reading: SNA-079259_2020-12-11-test_spike2_run003.h5... done.\n", "reading: SNA-079259_2020-12-11-test_spike2_run004.h5... done.\n", "reading: SNA-079259_2020-12-11-test_spike2_run005.h5... done.\n", "reading: SNA-079260_2020-12-06-train_spike2_run001.h5... done.\n", "reading: SNA-079260_2020-12-11-test_spike2_run001.h5... done.\n", "reading: SNA-079260_2020-12-11-test_spike2_run002.h5... done.\n", "reading: SNA-079260_2020-12-11-test_spike2_run003.h5... done.\n", "reading: SNA-079260_2020-12-11-test_spike2_run004.h5... done.\n", "reading: SNA-079260_2020-12-11-test_spike2_run005.h5... done.\n", "reading: SNA-079260_2020-12-11-test_spike2_run006.h5... done.\n" ] } ], "source": [ "latency = tuple()\n", "\n", "for subdir in sorted(srcroot.glob(\"SNA-*\")):\n", " for sessdir in sorted(subdir.glob(\"2020-*\")):\n", " for srcpath in sorted(sessdir.glob(\"*.h5\")):\n", " print(f\"reading: {srcpath.name}...\", end=\" \", flush=True)\n", " latency = latency + LatencyDescription.from_file(srcpath)\n", " print(\"done.\", flush=True)" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "processing: SNA-079258, session 2020-12-04-train, run 001, epoch 001... done.\n", "processing: SNA-079258, session 2020-12-04-train, run 002, epoch 001... done.\n", "processing: SNA-079258, session 2020-12-04-train, run 003, epoch 001... done.\n", "processing: SNA-079258, session 2020-12-06-train, run 001, epoch 001... done.\n", "processing: SNA-079258, session 2020-12-06-train, run 002, epoch 001... done.\n", "processing: SNA-079258, session 2020-12-06-train, run 003, epoch 001... done.\n", "processing: SNA-079258, session 2020-12-06-train, run 004, epoch 001... done.\n", "processing: SNA-079258, session 2020-12-06-train, run 005, epoch 001... done.\n", "processing: SNA-079258, session 2020-12-07-train, run 001, epoch 001... done.\n", "processing: SNA-079258, session 2020-12-07-train, run 001, epoch 002... done.\n", "processing: SNA-079258, session 2020-12-07-train, run 002, epoch 001... done.\n", "processing: SNA-079258, session 2020-12-07-train, run 003, epoch 001... done.\n", "processing: SNA-079258, session 2020-12-07-train, run 004, epoch 001... done.\n", "processing: SNA-079258, session 2020-12-11-train, run 001, epoch 001... done.\n", "processing: SNA-079258, session 2020-12-11-train, run 002, epoch 001... done.\n", "processing: SNA-079258, session 2020-12-11-train, run 003, epoch 001... done.\n", "processing: SNA-079259, session 2020-12-06-train, run 001, epoch 001... done.\n", "processing: SNA-079259, session 2020-12-06-train, run 001, epoch 002... done.\n", "processing: SNA-079259, session 2020-12-11-train, run 001, epoch 001... done.\n", "processing: SNA-079259, session 2020-12-11-train, run 002, epoch 001... done.\n", "processing: SNA-079259, session 2020-12-11-train, run 003, epoch 001... done.\n", "processing: SNA-079259, session 2020-12-11-train, run 004, epoch 001... done.\n", "processing: SNA-079259, session 2020-12-11-train, run 005, epoch 001... done.\n", "processing: SNA-079260, session 2020-12-06-train, run 001, epoch 001... done.\n", "processing: SNA-079260, session 2020-12-06-train, run 001, epoch 002... done.\n", "processing: SNA-079260, session 2020-12-11-train, run 001, epoch 001... done.\n", "processing: SNA-079260, session 2020-12-11-train, run 002, epoch 001... done.\n", "processing: SNA-079260, session 2020-12-11-train, run 003, epoch 001... done.\n", "processing: SNA-079260, session 2020-12-11-train, run 004, epoch 001... done.\n", "processing: SNA-079260, session 2020-12-11-train, run 005, epoch 001... done.\n", "processing: SNA-079260, session 2020-12-11-train, run 006, epoch 001... done.\n", "processing: SNA-079260, session 2020-12-11-train, run 006, epoch 002... done.\n", "all acquisitions written to the file.\n" ] } ], "source": [ "opts = dict(compression=5)\n", "with h5py.File(\"latency_data.h5\", \"w\") as out:\n", " frame_intervals = out.create_group(\"frame_intervals\")\n", " frame_intervals.attrs[\"description\"] = \"a set of frame-to-frame intervals during each acquisition period.\"\n", " frame_intervals.attrs[\"unit\"] = \"samples\"\n", " frame_intervals.attrs[\"sampling_rate_hz\"] = 10000\n", " \n", " on_latency = out.create_group(\"on_latency\")\n", " on_latency.attrs[\"description\"] = \"a set of latencies to turn on the trigger after the corresponding exposure-start timings. if it was >50 ms, a `-1` is set.\"\n", " on_latency.attrs[\"unit\"] = \"samples\"\n", " on_latency.attrs[\"sampling_rate_hz\"] = 10000\n", " \n", " off_latency = out.create_group(\"off_latency\")\n", " off_latency.attrs[\"description\"] = \"a set of latencies to turn off the trigger after the corresponding exposure-start timings. if it was >50 ms, a `-1` is set.\"\n", " off_latency.attrs[\"unit\"] = \"samples\"\n", " off_latency.attrs[\"sampling_rate_hz\"] = 10000\n", " \n", " for i, lat in enumerate(latency, start=1):\n", " print(f\"processing: {lat.subject}, session {lat.session}, run {lat.run}, epoch {lat.epoch}...\", end=\" \", flush=True)\n", " acq_name = str(i).zfill(3)\n", " for attr in (\"frame_intervals\", \"on_latency\", \"off_latency\"):\n", " values = getattr(lat, attr)\n", " if values is None:\n", " continue\n", " acq = out[attr].create_dataset(acq_name, data=values, **opts)\n", " for metadata in (\"subject\", \"session\", \"run\", \"epoch\"):\n", " acq.attrs[metadata] = getattr(lat, metadata)\n", " frame_intervals[acq_name].attrs[\"has_trigger\"] = lat.has_trigger\n", " print(\"done.\", flush=True)\n", "print(\"all acquisitions written to the file.\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "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.8.5" } }, "nbformat": 4, "nbformat_minor": 4 }