From 1b4553d1de2a2fcd8c50006e1f54240a62560620 Mon Sep 17 00:00:00 2001 From: Kyle Johnsen Date: Mon, 1 Apr 2024 14:42:12 -0400 Subject: [PATCH] patch LFP (#46) * fix RWSLFPFromPSCs buffer issue * add style_plots_for_paper() * bump to v0.14.1 * add section headings to advanced_lfp.ipynb * fix RWSLFPFromPSCs buffer, add tests * use rounded sample times to avoid skips * add LFP comparison notebook --- cleo/base.py | 8 +- cleo/ephys/lfp.py | 56 +++- cleo/ioproc/base.py | 2 +- cleo/utilities.py | 13 + docs/tutorials/advanced_lfp.ipynb | 9 + notebooks/lfp_comparison.ipynb | 447 ++++++++++++++++++++++++++++++ pyproject.toml | 2 +- tests/ephys/test_lfp.py | 112 ++++++-- tests/ioproc/test_processing.py | 31 ++- 9 files changed, 633 insertions(+), 47 deletions(-) create mode 100644 notebooks/lfp_comparison.ipynb diff --git a/cleo/base.py b/cleo/base.py index 4a67d64..da79b63 100644 --- a/cleo/base.py +++ b/cleo/base.py @@ -460,9 +460,11 @@ def set_io_processor( return def communicate_with_io_proc(t): - if io_processor.is_sampling_now(t / ms): - io_processor.put_state(self.get_state(), t / ms) - stim_values = io_processor.get_stim_values(t / ms) + # assuming no one will have timesteps shorter than nanoseconds... + now_ms = round(t / ms, 6) + if io_processor.is_sampling_now(now_ms): + io_processor.put_state(self.get_state(), now_ms) + stim_values = io_processor.get_stim_values(now_ms) self.update_stimulators(stim_values) # communication should be at every timestep. The IOProcessor diff --git a/cleo/ephys/lfp.py b/cleo/ephys/lfp.py index 7eba408..20e6615 100644 --- a/cleo/ephys/lfp.py +++ b/cleo/ephys/lfp.py @@ -5,7 +5,7 @@ from collections import deque from datetime import datetime from itertools import chain -from math import floor +from math import ceil from numbers import Number from typing import Any, Union @@ -241,6 +241,12 @@ class RWSLFPSignalBase(LFPSignalBase): """Whether to aggregate currents across the population (as opposed to neurons having differential contributions to LFP depending on their location). False by default.""" + wslfp_kwargs: dict = field(factory=dict) + """Keyword arguments to pass to the WSLFP calculator, e.g., ``alpha``, + ``tau_ampa_ms``, ``tau_gaba_ms````source_coords_are_somata``, + ``source_dendrite_length_um``, ``amp_kwargs``, ``strict_boundaries``. + """ + _wslfps: dict[NeuronGroup, wslfp.WSLFPCalculator] = field( init=False, factory=dict, repr=False ) @@ -271,6 +277,8 @@ def _init_wslfp_calc(self, neuron_group: NeuronGroup, **kwparams): ]: if key in kwparams: wslfp_kwargs[key] = kwparams.pop(key) + elif key in self.wslfp_kwargs: + wslfp_kwargs[key] = self.wslfp_kwargs[key] self._wslfps[neuron_group] = wslfp.from_xyz_coords( self._elec_coords / um, @@ -595,7 +603,9 @@ def connect_to_neuron_group(self, neuron_group: NeuronGroup, **kwparams): self._init_wslfp_calc(neuron_group, **kwparams) - buf_len_ampa, buf_len_gaba = self._get_buf_lens(self._wslfps[neuron_group]) + buf_len_ampa, buf_len_gaba = self._get_buf_lens_for_wslfp( + self._wslfps[neuron_group] + ) self._t_ampa_bufs[neuron_group] = deque(maxlen=buf_len_ampa) self._I_ampa_bufs[neuron_group] = deque(maxlen=buf_len_ampa) self._t_gaba_bufs[neuron_group] = deque(maxlen=buf_len_gaba) @@ -605,7 +615,10 @@ def connect_to_neuron_group(self, neuron_group: NeuronGroup, **kwparams): self._ampa_vars[neuron_group] = [varname + "_" for varname in I_ampa_names] self._gaba_vars[neuron_group] = [varname + "_" for varname in I_gaba_names] - def _get_buf_lens(self, wslfp_calc, **kwparams): + def _buf_len(self, tau, dt): + return ceil((tau + dt) / dt) + + def _get_buf_lens_for_wslfp(self, wslfp_calc, **kwparams): # need sampling period sample_period_ms = kwparams.get("sample_period_ms", None) if sample_period_ms is None: @@ -619,14 +632,14 @@ def _get_buf_lens(self, wslfp_calc, **kwparams): f" specify it on injection: .inject({self.probe.name}" ", sample_period_ms=...)" ) - buf_len_ampa = floor(wslfp_calc.tau_ampa_ms / sample_period_ms + 1) - buf_len_gaba = floor(wslfp_calc.tau_gaba_ms / sample_period_ms + 1) + buf_len_ampa = self._buf_len(wslfp_calc.tau_ampa_ms, sample_period_ms) + buf_len_gaba = self._buf_len(wslfp_calc.tau_gaba_ms, sample_period_ms) return buf_len_ampa, buf_len_gaba def _curr_from_buffer(self, t_buf_ms, I_buf, t_eval_ms: float, n_sources): # t_eval_ms is not iterable empty = np.zeros((1, n_sources)) - if len(t_buf_ms) == 0 or t_buf_ms[0] > t_eval_ms: + if len(t_buf_ms) == 0 or t_buf_ms[0] > t_eval_ms or t_buf_ms[-1] < t_eval_ms: return empty # when tau is multiple of sample time, current should be collected # right when needed, at the left end of the buffer @@ -636,10 +649,31 @@ def _curr_from_buffer(self, t_buf_ms, I_buf, t_eval_ms: float, n_sources): # if not, should only need to interpolate between first and second positions # if buffer length is correct assert len(t_buf_ms) > 1 - assert t_buf_ms[0] < t_eval_ms < t_buf_ms[1] - I_interp = I_buf[0] + (I_buf[1] - I_buf[0]) * (t_eval_ms - t_buf_ms[0]) / ( - t_buf_ms[1] - t_buf_ms[0] - ) + if t_buf_ms[0] < t_eval_ms < t_buf_ms[1]: + i_l, i_r = 0, 1 + else: + warnings.warn( + f"Time buffer is unexpected. Did a sample get skipped? " + f"t_buf_ms={t_buf_ms}, t_eval_ms={t_eval_ms}" + ) + i_l, i_r = None, None + for i, t in enumerate(t_buf_ms): + if t < t_eval_ms: + i_l = i + if t >= t_eval_ms: + i_r = i + break + if i_l is None or i_r is None or i_l >= i_r: + warnings.warn( + "Signal buffer does not contain currents at needed timepoints. " + "Returning 0. " + f"t_buf_ms={t_buf_ms}, t_eval_ms={t_eval_ms}" + ) + return empty + + I_interp = I_buf[i_l] + (I_buf[i_r] - I_buf[i_l]) * ( + t_eval_ms - t_buf_ms[i_l] + ) / (t_buf_ms[i_r] - t_buf_ms[i_l]) I_interp = np.reshape(I_interp, (1, n_sources)) I_interp = np.nan_to_num(I_interp, nan=0) @@ -683,7 +717,7 @@ def _needed_current( def reset(self, **kwargs) -> None: self._init_saved_vars() for ng in self._t_ampa_bufs: - buf_len_ampa, buf_len_gaba = self._get_buf_lens(self._wslfps[ng]) + buf_len_ampa, buf_len_gaba = self._get_buf_lens_for_wslfp(self._wslfps[ng]) self._t_ampa_bufs[ng] = deque(maxlen=buf_len_ampa) self._I_ampa_bufs[ng] = deque(maxlen=buf_len_ampa) self._t_gaba_bufs[ng] = deque(maxlen=buf_len_gaba) diff --git a/cleo/ioproc/base.py b/cleo/ioproc/base.py index 55b1d0e..78c0a6a 100644 --- a/cleo/ioproc/base.py +++ b/cleo/ioproc/base.py @@ -196,7 +196,7 @@ def is_sampling_now(self, query_time_ms): if np.isclose(query_time_ms % self.sample_period_ms, 0): return True elif self.sampling == "when idle": - if query_time_ms % self.sample_period_ms == 0: + if np.isclose(query_time_ms % self.sample_period_ms, 0): if self._is_currently_idle(query_time_ms): self._needs_off_schedule_sample = False return True diff --git a/cleo/utilities.py b/cleo/utilities.py index a8f9b82..3757e9e 100644 --- a/cleo/utilities.py +++ b/cleo/utilities.py @@ -295,6 +295,19 @@ def style_plots_for_docs(dark=True): plt.rc("font", **{"sans-serif": "Open Sans"}) +def style_plots_for_paper(): + # some hacky workaround for params not being updated until after first plot + f = plt.figure() + plt.plot() + plt.close(f) + + plt.style.use("seaborn-v0_8-paper") + plt.rc("savefig", transparent=True, bbox="tight", dpi=300) + plt.rc("svg", fonttype="none") + plt.rc("axes.spines", top=False, right=False) + plt.rc("font", **{"sans-serif": "Open Sans"}) + + def unit_safe_append(q1: Quantity, q2: Quantity, axis=0): if not b2.have_same_dimensions(q1, q2): raise ValueError("Dimensions must match") diff --git a/docs/tutorials/advanced_lfp.ipynb b/docs/tutorials/advanced_lfp.ipynb index b662b0f..0639d6a 100644 --- a/docs/tutorials/advanced_lfp.ipynb +++ b/docs/tutorials/advanced_lfp.ipynb @@ -226,6 +226,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "## RWSLFP recording options\n", + "\n", "There are a few important variations on how to record RWSLFP:\n", "- Currents can be summed over the population, so that a postsynaptic current (PSC) in one location has the same effect on LFP as one on the other side of the population.\n", " The main advantage to this approach is it saves some memory storing currents.\n", @@ -352,6 +354,13 @@ "sim.inject(probe, inh, tklfp_type=\"inh\")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run simulation and plot results" + ] + }, { "cell_type": "code", "execution_count": 9, diff --git a/notebooks/lfp_comparison.ipynb b/notebooks/lfp_comparison.ipynb new file mode 100644 index 0000000..e03769e --- /dev/null +++ b/notebooks/lfp_comparison.ipynb @@ -0,0 +1,447 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# RWSLFP/TKLFP comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# preamble:\n", + "import brian2.only as b2\n", + "from brian2 import np\n", + "import matplotlib.pyplot as plt\n", + "import cleo\n", + "from cleo import ephys\n", + "import cleo.utilities\n", + "\n", + "# the default cython compilation target isn't worth it for\n", + "# this trivial example\n", + "b2.prefs.codegen.target = \"numpy\"\n", + "b2.seed(17570111)\n", + "np.random.seed(17570111)\n", + "rng = np.random.default_rng(17570111)\n", + "\n", + "cleo.utilities.style_plots_for_paper()\n", + "\n", + "# colors\n", + "c = {\n", + " \"light\": \"#df87e1\",\n", + " \"main\": \"#C500CC\",\n", + " \"dark\": \"#8000B4\",\n", + " \"exc\": \"#d6755e\",\n", + " \"inh\": \"#056eee\",\n", + " \"accent\": \"#36827F\",\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Network setup\n", + "\n", + "First we need a point neuron simulation to approximate the LFP for.\n", + "Here we adapt a balanced E/I network implementation [from the Neuronal Dynamics textbook](https://neuronaldynamics-exercises.readthedocs.io/en/latest/_modules/neurodynex3/brunel_model/LIF_spiking_network.html#simulate_brunel_network), using some parameters from [Mazzoni, Lindén et al., 2015](https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1004584)." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "n_exc = 800\n", + "n_inh = None # None = N_excit / 4\n", + "n_ext = 100\n", + "connection_probability = 0.2\n", + "w0 = 0.07 * b2.nA\n", + "g = 4\n", + "synaptic_delay = 1 * b2.ms\n", + "poisson_input_rate = 220 * b2.Hz\n", + "w_ext = 0.091 * b2.nA\n", + "v_rest = -70 * b2.mV\n", + "v_reset = -60 * b2.mV\n", + "firing_threshold = -50 * b2.mV\n", + "membrane_time_scale = 20 * b2.ms\n", + "Rm = 100 * b2.Mohm\n", + "abs_refractory_period = 2 * b2.ms\n", + "\n", + "if n_inh is None:\n", + " n_inh = int(n_exc / 4)\n", + "N_tot = n_exc + n_inh\n", + "if n_ext is None:\n", + " n_ext = int(n_exc * connection_probability)\n", + "if w_ext is None:\n", + " w_ext = w0\n", + "\n", + "J_excit = w0\n", + "J_inhib = -g * w0\n", + "\n", + "lif_dynamics = \"\"\"\n", + " dv/dt = (-(v-v_rest) + Rm*(I_exc + I_ext + I_gaba)) / membrane_time_scale : volt (unless refractory)\n", + " I_gaba : amp\n", + " I_exc : amp\n", + " I_ext : amp\n", + "\"\"\"\n", + "\n", + "neurons = b2.NeuronGroup(\n", + " N_tot,\n", + " model=lif_dynamics,\n", + " threshold=\"v>firing_threshold\",\n", + " reset=\"v=v_reset\",\n", + " refractory=abs_refractory_period,\n", + " method=\"linear\",\n", + ")\n", + "neurons.v = (\n", + " np.random.uniform(\n", + " v_rest / b2.mV, high=firing_threshold / b2.mV, size=(n_exc + n_inh)\n", + " )\n", + " * b2.mV\n", + ")\n", + "cleo.coords.assign_coords_rand_cylinder(\n", + " neurons, (0, 0, 700), (0, 0, 900), 250, unit=b2.um\n", + ")\n", + "\n", + "exc = neurons[:n_exc]\n", + "inh = neurons[n_exc:]\n", + "\n", + "syn_eqs = \"\"\"\n", + " dI_syn_syn/dt = (s - I_syn_syn)/tau_dsyn : amp (clock-driven)\n", + " I_TYPE_post = I_syn_syn : amp (summed)\n", + " ds/dt = -s/tau_rsyn : amp (clock-driven)\n", + "\"\"\"\n", + "\n", + "exc_synapses = b2.Synapses(\n", + " exc,\n", + " target=neurons,\n", + " model=syn_eqs.replace(\"TYPE\", \"exc\"),\n", + " on_pre=\"s += w\",\n", + " delay=synaptic_delay,\n", + " namespace={\"tau_rsyn\": 0.4 * b2.ms, \"tau_dsyn\": 2 * b2.ms, \"w\": J_excit},\n", + ")\n", + "exc_synapses.connect(p=connection_probability)\n", + "\n", + "inh_synapses = b2.Synapses(\n", + " inh,\n", + " target=neurons,\n", + " model=syn_eqs.replace(\"TYPE\", \"gaba\"),\n", + " on_pre=\"s += w\",\n", + " delay=synaptic_delay,\n", + " namespace={\"tau_rsyn\": 0.4 * b2.ms, \"tau_dsyn\": 2 * b2.ms, \"w\": J_inhib},\n", + ")\n", + "inh_synapses.connect(p=connection_probability)\n", + "\n", + "ext_input = b2.PoissonGroup(n_ext, poisson_input_rate, name=\"ext_input\")\n", + "ext_synapses = b2.Synapses(\n", + " ext_input,\n", + " target=neurons,\n", + " model=syn_eqs.replace(\"TYPE\", \"ext\"),\n", + " on_pre=\"s += w\",\n", + " delay=synaptic_delay,\n", + " namespace={\"tau_rsyn\": 0.4 * b2.ms, \"tau_dsyn\": 2 * b2.ms, \"w\": w_ext},\n", + ")\n", + "ext_synapses.connect(p=connection_probability)\n", + "\n", + "net = b2.Network(\n", + " neurons,\n", + " exc_synapses,\n", + " inh_synapses,\n", + " ext_input,\n", + " ext_synapses,\n", + ")\n", + "sim = cleo.CLSimulator(net)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Electrode setup" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "elec_coords = cleo.ephys.linear_shank_coords(1 * b2.mm, channel_count=10)\n", + "elec_coords = cleo.ephys.tile_coords(\n", + " elec_coords, num_tiles=3, tile_vector=(0, -500, 0) * b2.um\n", + ")\n", + "probe = cleo.ephys.Probe(elec_coords)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = cleo.viz.plot(\n", + " exc,\n", + " inh,\n", + " colors=[c[\"exc\"], c[\"inh\"]],\n", + " zlim=(0, 1200),\n", + " devices=[probe],\n", + " scatterargs={\"alpha\": 0.4, \"rasterized\": True, \"s\": 3},\n", + " figsize=(3, 3),\n", + ")\n", + "fig.savefig(\"img/fig/tklfp-rwslfp-3d.svg\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "mua = ephys.MultiUnitSpiking(\n", + " r_perfect_detection=0.05 * b2.mm,\n", + " r_half_detection=0.1 * b2.mm,\n", + ")\n", + "ss = ephys.SortedSpiking(0.05 * b2.mm, 0.1 * b2.mm)\n", + "tklfp = ephys.TKLFPSignal()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "import wslfp\n", + "\n", + "rwslfp = ephys.RWSLFPSignalFromSpikes(syn_delay=synaptic_delay)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "CLSimulator(io_processor=RecordOnlyProcessor(sample_period_ms=1, sampling='fixed', processing='parallel'), devices={Probe(name='Probe', save_history=True, signals=[MultiUnitSpiking(name='MultiUnitSpiking', brian_objects={, }, probe=..., r_perfect_detection=50. * umetre, r_half_detection=100. * umetre, cutoff_probability=0.01), SortedSpiking(name='SortedSpiking', brian_objects={, }, probe=..., r_perfect_detection=50. * umetre, r_half_detection=100. * umetre, cutoff_probability=0.01), TKLFPSignal(name='TKLFPSignal', brian_objects={, }, probe=..., uLFP_threshold_uV=0.001, _lfp_unit=uvolt), RWSLFPSignalFromSpikes(name='RWSLFPSignalFromSpikes', brian_objects={, , }, probe=..., amp_func=, pop_aggregate=False, _lfp_unit=1, tau1_ampa=2. * msecond, tau2_ampa=0.4 * msecond, tau1_gaba=5. * msecond, tau2_gaba=250. * usecond, syn_delay=1. * msecond, I_threshold=0.001, weight='w')], probe=NOTHING)})" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "probe.add_signals(\n", + " mua,\n", + " ss,\n", + " tklfp,\n", + " rwslfp,\n", + ")\n", + "\n", + "sim.set_io_processor(cleo.ioproc.RecordOnlyProcessor(sample_period_ms=1))\n", + "sim.inject(\n", + " probe,\n", + " exc,\n", + " # for TKLFPSignal:\n", + " tklfp_type=\"exc\",\n", + " # for RWSLFPSignalFromSpikes:\n", + " ampa_syns=[\n", + " # want only synapses onto pyramidal cells\n", + " (exc_synapses[f\"j < {n_exc}\"]),\n", + " (ext_synapses[f\"j < {n_exc}\"]),\n", + " ],\n", + " gaba_syns=[(inh_synapses[f\"j < {n_exc}\"])],\n", + ")\n", + "# we don't include ampa_syns, gaba_syns, Iampa_var_name, or Igaba_var_name since RWSLFP\n", + "# is only recorded from pyramidal cells\n", + "sim.inject(probe, inh, tklfp_type=\"inh\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run simulation and plot results" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO No numerical integration method specified for group 'synapses_3', using method 'exact' (took 0.00s). [brian2.stateupdaters.base.method_choice]\n", + "INFO No numerical integration method specified for group 'synapses_4', using method 'exact' (took 0.00s). [brian2.stateupdaters.base.method_choice]\n", + "INFO No numerical integration method specified for group 'synapses_5', using method 'exact' (took 0.00s). [brian2.stateupdaters.base.method_choice]\n" + ] + } + ], + "source": [ + "sim.reset()\n", + "sim.run(1 * b2.second)" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from matplotlib.colors import ListedColormap\n", + "\n", + "fig, axs_psd = plt.subplots(2, 1, sharex=True, figsize=(4, 3), layout=\"constrained\")\n", + "\n", + "# assuming all neurons are detectable for c=ss.i >= n_e to work\n", + "# in practice this will often not be the case and we'd have to map\n", + "# from probe index to neuron group index using ss.i_probe_by_i_ng.inverse\n", + "exc_inh_cmap = ListedColormap([c[\"exc\"], c[\"inh\"]])\n", + "axs_psd[0].scatter(\n", + " ss.t_ms, ss.i, marker=\".\", c=ss.i >= n_exc, cmap=exc_inh_cmap, s=3, rasterized=True\n", + ")\n", + "axs_psd[0].set(title=\"sorted spikes\", ylabel=\"neuron index\")\n", + "\n", + "axs_psd[1].scatter(mua.t_ms, mua.i, marker=\".\", s=2, c=\"k\", rasterized=True)\n", + "axs_psd[1].set(title=\"multi-unit activity\", ylabel=\"channel index\", xlabel=\"time [ms]\")\n", + "fig.savefig(\"img/fig/tklfp-rwslfp-spikes.svg\")" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from scipy.signal import welch\n", + "\n", + "n_shanks = 3\n", + "fig = plt.figure(figsize=(7, 6.5))\n", + "subfigs = fig.subfigures(1, 2, width_ratios=[2, 1])\n", + "axs_lfp = subfigs[0].subplots(2, n_shanks, sharex=True)\n", + "axs_psd = subfigs[1].subplots(2, 1, sharey=False, sharex=True)\n", + "\n", + "\n", + "def plot_lfp(t_ms, lfp, axs, title=None):\n", + " n_contacts_per_shank = 10\n", + " for i, color, ax in zip(range(n_shanks), [c[\"dark\"], c[\"main\"], c[\"light\"]], axs):\n", + " lfp_for_shank = lfp[\n", + " :, i * n_contacts_per_shank : (i + 1) * n_contacts_per_shank\n", + " ]\n", + " ax.plot(\n", + " t_ms,\n", + " lfp_for_shank + np.arange(n_contacts_per_shank) * 0.9 * np.abs(lfp.max()),\n", + " c=color,\n", + " lw=1,\n", + " rasterized=True,\n", + " )\n", + " ax.set(yticks=[])\n", + "\n", + " axs[0].set(ylabel=\"LFP [a.u.] per channel (sorted by depth)\")\n", + " if title:\n", + " axs[1].set(title=title)\n", + " # axs[1].text(\n", + " # 0.5, 1.1, title, ha=\"center\", va=\"bottom\", transform=axs[1].transAxes\n", + " # )\n", + "\n", + "\n", + "for i, signal in enumerate([tklfp, rwslfp]):\n", + " plot_lfp(signal.t_ms, signal.lfp, axs_lfp[i, :], title=\"\")\n", + "for ax in axs_lfp[-1, :]:\n", + " ax.set(xlabel=\"time [ms]\")\n", + "\n", + "\n", + "def plot_psd(lfp, ax, fs=1000, title=None):\n", + " for i_shank, color in enumerate([c[\"dark\"], c[\"main\"], c[\"light\"]]):\n", + " f, p = welch(lfp[:, i_shank * 10 : (i_shank + 1) * 10].T, fs=fs)\n", + " ax.semilogy(\n", + " f,\n", + " p.T.mean(axis=1),\n", + " c=color,\n", + " label=f\"rec. radius = {i_shank * 250} µm\",\n", + " rasterized=True,\n", + " )\n", + " ax.set(ylabel=\"PSD [V²/Hz]\", yticks=[])\n", + " if title:\n", + " ax.set(title=title)\n", + "\n", + "\n", + "fig.text(0.5, 1, \"TKLFP\", ha=\"center\", va=\"top\")\n", + "fig.text(0.5, 0.5, \"RWSLFP\", ha=\"center\", va=\"bottom\")\n", + "# make room for titles\n", + "subplots_adjust_kwargs = dict(top=0.95)\n", + "for sf in subfigs:\n", + " sf.subplots_adjust(**subplots_adjust_kwargs)\n", + "\n", + "plot_psd(tklfp.lfp, axs_psd[0], title=\"\")\n", + "plot_psd(rwslfp.lfp, axs_psd[1], title=\"\")\n", + "axs_psd[0].legend()\n", + "axs_psd[1].set(xlabel=\"frequency [Hz]\")\n", + "fig.savefig(\"img/fig/tklfp-rwslfp-lfp-psd.svg\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "cleo", + "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.12.1" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/pyproject.toml b/pyproject.toml index c8b7b1b..9a77cc0 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "cleosim" -version = "0.14.0" +version = "0.14.1" description = "Cleo: the Closed-Loop, Electrophysiology, and Optogenetics experiment simulation testbed" authors = [ "Kyle Johnsen ", diff --git a/tests/ephys/test_lfp.py b/tests/ephys/test_lfp.py index a1142f1..6542473 100644 --- a/tests/ephys/test_lfp.py +++ b/tests/ephys/test_lfp.py @@ -234,6 +234,23 @@ def test_lfp_signal_to_neo(LFPSignal, n_channels, t, regular_samples): assert neo_sig.name == f"{sig.probe.name}.{sig.name}" +_base_param_options = [ + ("pop_agg", (True, False)), + ("amp_func", (wslfp.aussel18, wslfp.mazzoni15_pop)), + # ("wslfp_kwargs", ({}, {"tau_ampa_ms": 5})), + ("wslfp_kwargs", ({}, {"tau_gaba_ms": 1})), + ("wslfp_kwargs", ({}, {"alpha": 1})), + ( + "wslfp_kwargs", + ({"source_coords_are_somata": True}, {"source_coords_are_somata": False}), + ), + ( + "wslfp_kwargs", + ({"source_dendrite_length_um": 250}, {"source_dendrite_length_um": 300}), + ), +] + + def test_RWSLFPSignalFromSpikes(rand_seed): rng = np.random.default_rng(rand_seed) b2.seed(rand_seed) @@ -259,6 +276,7 @@ def add_rwslfp_sig( pop_agg=True, amp_func=wslfp.mazzoni15_pop, ornt=[0, 0, -1], + wslfp_kwargs={}, tau1_ampa=2 * ms, tau2_ampa=0.4 * ms, tau1_gaba=5 * ms, @@ -276,6 +294,7 @@ def add_rwslfp_sig( tau2_gaba=tau2_gaba, syn_delay=syn_delay, I_threshold=I_threshold, + wslfp_kwargs=wslfp_kwargs, ) # separate probe for each signal since some injection kwargs need to be different per signal i = len(sim.recorders) @@ -293,10 +312,8 @@ def add_rwslfp_sig( ) return rwslfp_sig - signals_by_param = {} - for param_name, param_vals in [ - ("pop_agg", (True, False)), - ("amp_func", (wslfp.aussel18, wslfp.mazzoni15_pop)), + signals_for_options = [] + param_options = [ ("ornt", (rng.normal(size=(n_exc, 3)), (-0.2, -0.1, -0.3))), ("tau1_ampa", (2, 1) * ms), ("tau2_ampa", (0.4, 0.2) * ms), @@ -305,18 +322,23 @@ def add_rwslfp_sig( ("syn_delay", (1, 2) * ms), ("homog_J", (True, False)), ("I_threshold", (0.1, 0.001)), - ]: - signals_by_param[param_name] = [] + ] + for param_name, param_vals in _base_param_options + param_options: + signals_to_compare = [] for val in param_vals: # store result of each different value for each param - signals_by_param[param_name].append(add_rwslfp_sig(**{param_name: val})) + signals_to_compare.append(add_rwslfp_sig(**{param_name: val})) + signals_for_options.append((param_name, signals_to_compare)) sim.run(100 * ms) # each parameter change should change the resulting signal: - for param, signals in signals_by_param.items(): + assert len(signals_for_options) == len(_base_param_options) + len(param_options) + for param, signals in signals_for_options: assert len(signals) > 1 for i, sig1 in enumerate(signals): for sig2 in signals[i + 1 :]: - assert not np.allclose(sig1.lfp, sig2.lfp) + assert not np.allclose( + sig1.lfp, sig2.lfp + ), f"{param} variation not yielding different results" @pytest.mark.parametrize("samp_period_ms", [1, 1.4]) @@ -325,7 +347,7 @@ def test_RWSLFPSignalFromPSCs(rand_seed, samp_period_ms): b2.seed(rand_seed) n_exc = 16 n_elec = 4 - elec_coords = rng.uniform(-1, 1, (n_elec, 3)) * mm + elec_coords = rng.uniform(-0.5, 0.5, (n_elec, 3)) * mm exc = b2.NeuronGroup( n_exc, @@ -335,7 +357,7 @@ def test_RWSLFPSignalFromPSCs(rand_seed, samp_period_ms): dIgaba2/dt = xi_4 / sqrt(dt) : 1 """, ) - assign_coords(exc, rng.uniform(-1, 1, (n_exc, 3)) * mm) + assign_coords(exc, rng.uniform(-0.5, 0.5, (n_exc, 3)) * mm) # cleo setup sim = CLSimulator(Network(exc)) @@ -345,13 +367,18 @@ def add_rwslfp_sig( pop_agg=True, amp_func=wslfp.mazzoni15_pop, ornt=[0, 0, -1], + wslfp_kwargs={}, Iampa_var_names=["Iampa1"], Igaba_var_names=["Igaba1"], + name=None, ): rwslfp_sig = RWSLFPSignalFromPSCs( pop_aggregate=pop_agg, amp_func=amp_func, + wslfp_kwargs=wslfp_kwargs, ) + if name: + rwslfp_sig.name = name # separate probe for each signal since some injection kwargs need to be different per signal i = len(sim.recorders) probe = Probe(elec_coords, [rwslfp_sig], name=f"probe{i}") @@ -365,25 +392,70 @@ def add_rwslfp_sig( ) return rwslfp_sig - signals_by_param = {} - for param_name, param_vals in [ - ("pop_agg", (True, False)), - ("amp_func", (wslfp.aussel18, wslfp.mazzoni15_pop)), + signals_for_options = [] + param_options = [ ("ornt", (rng.normal(size=(n_exc, 3)), (-0.2, -0.1, -0.3))), ("Iampa_var_names", (["Iampa1"], ["Iampa1", "Iampa2"])), ("Igaba_var_names", (["Igaba1"], ["Igaba1", "Igaba2"])), - ]: - signals_by_param[param_name] = [] + ] + for param_name, param_vals in _base_param_options + param_options: + signals = [] for val in param_vals: # store result of each different value for each param - signals_by_param[param_name].append(add_rwslfp_sig(**{param_name: val})) + signals.append( + add_rwslfp_sig(**{param_name: val}, name=f"{param_name}_{val}") + ) + signals_for_options.append((param_name, signals)) sim.run(30 * ms) + assert not np.allclose(exc.Iampa1_, exc.Iampa2_) # each parameter change should change the resulting signal: - for param, signals in signals_by_param.items(): + assert len(signals_for_options) == len(_base_param_options) + len(param_options) + for param, signals in signals_for_options: assert len(signals) > 1 for i, sig1 in enumerate(signals): for sig2 in signals[i + 1 :]: - assert not np.allclose(sig1.lfp, sig2.lfp) + assert not np.allclose( + sig1.lfp, sig2.lfp + ), f"{sig1.name} and {sig2.name} not yielding different results" + + +def test_psc_buffer(): + sig = RWSLFPSignalFromPSCs() + t_buf = [1, 2, 4] # skipped 3 for some reason; should be [2, 3, 4] + n_src = 4 + I_buf = np.arange(3)[..., None] + np.arange(n_src) + print(I_buf) + t_eval = 2 + with pytest.warns(match="buffer is unexpected"): + assert np.all( + sig._curr_from_buffer(t_buf, I_buf, t_eval, n_sources=n_src) + == np.arange(1, 5) + ) + assert np.all( + sig._curr_from_buffer([1, 3, 4], I_buf, t_eval, n_sources=n_src) + == np.arange(0.5, 4.5) + ) + + assert np.all(sig._curr_from_buffer([3, 4, 5], I_buf, t_eval, n_sources=n_src) == 0) + assert np.all( + sig._curr_from_buffer([-1, 0, 1], I_buf, t_eval, n_sources=n_src) == 0 + ) + + +def test_psc_buf_len(): + sig = RWSLFPSignalFromPSCs() + # args are buf_width, sample_period + assert sig._buf_len(0, 1) == 1 + assert sig._buf_len(0, 1.5) == 1 + assert sig._buf_len(0, 12.13) == 1 + assert sig._buf_len(1, 1) == 2 + assert sig._buf_len(1, 0.5) == 3 + assert sig._buf_len(2, 1) == 3 + assert sig._buf_len(6, 1) == 7 + assert sig._buf_len(6, 1.2) == 6 + assert sig._buf_len(6, 1.4) == 6 + assert sig._buf_len(6, 1.5) == 5 + assert sig._buf_len(6, 1.6) == 5 if __name__ == "__main__": diff --git a/tests/ioproc/test_processing.py b/tests/ioproc/test_processing.py index e1d8c94..457ac40 100644 --- a/tests/ioproc/test_processing.py +++ b/tests/ioproc/test_processing.py @@ -1,9 +1,9 @@ """Tests for cleo/processing/__init__.py""" from typing import Any, Tuple -from brian2 import Hz, Network, PoissonGroup, ms, np +from brian2 import Hz, Network, NeuronGroup, ms, np -from cleo import CLSimulator +import cleo from cleo.ioproc import ConstantDelay, LatencyIOProcessor, ProcessingBlock @@ -111,25 +111,34 @@ def test_LatencyIOProcessor_wait_parallel(): _test_LatencyIOProcessor(myLIOP, t, sampling, inputs, outputs) -class SampleCounter(LatencyIOProcessor): +class SampleCounter(cleo.IOProcessor): """Just count samples""" - def __init__(self, sample_period_ms, **kwargs): - super().__init__(sample_period_ms, **kwargs) + def is_sampling_now(self, t_query_ms) -> np.bool: + return t_query_ms % self.sample_period_ms == 0 + + def __init__(self): self.count = 0 + self.sample_period_ms = 1 + self.latest_ctrl_signal = {} - def process(self, state_dict: dict, sample_time_ms: float) -> Tuple[dict, float]: + def put_state(self, state_dict: dict, sample_time_ms: float): self.count += 1 + print(sample_time_ms) return ({}, sample_time_ms) + def get_ctrl_signals(self, query_time_ms: np.float) -> dict: + return {} + def test_no_skip_sampling(): - sc = SampleCounter(1) - net = Network(PoissonGroup(1, 100 * Hz)) - sim = CLSimulator(net) + sc = SampleCounter() + net = Network() + sim = cleo.CLSimulator(net) sim.set_io_processor(sc) - sim.run(150 * ms) - assert sc.count == 150 + nsamp = 3000 + sim.run(nsamp * ms) + assert sc.count == nsamp class WaveformController(LatencyIOProcessor):