diff --git a/cleo/__init__.py b/cleo/__init__.py
index e270701..3853dce 100644
--- a/cleo/__init__.py
+++ b/cleo/__init__.py
@@ -1,9 +1,8 @@
"""Contains core classes and functions for the Cleo package."""
from __future__ import annotations
-import cleo.coords
-
# auto-import submodules
+import cleo.coords
import cleo.ephys
import cleo.imaging
import cleo.ioproc
@@ -17,6 +16,7 @@
CLSimulator,
InterfaceDevice,
IOProcessor,
+ NeoExportable,
Recorder,
Stimulator,
SynapseDevice,
diff --git a/cleo/coords.py b/cleo/coords.py
index 2940606..7206568 100644
--- a/cleo/coords.py
+++ b/cleo/coords.py
@@ -4,7 +4,7 @@
from typing import Tuple
-from brian2 import Quantity, Unit, meter, mm, np
+from brian2 import Quantity, Subgroup, Unit, meter, mm, np
from brian2.groups.group import Group
from brian2.groups.neurongroup import NeuronGroup
from brian2.units.fundamentalunits import get_dimensions
@@ -218,6 +218,15 @@ def _init_variables(group: Group):
else:
if type(group) == NeuronGroup:
modify_model_with_eqs(group, f"{dim_name}: meter")
+
+ elif isinstance(group, Subgroup):
+ if not hasattr(group.source, dim_name):
+ modify_model_with_eqs(group.source, f"{dim_name}: meter")
+ group.variables.add_references(
+ group.source, list(group.source.variables.keys())
+ )
+ assert dim_name in group.variables
+
elif issubclass(type(group), Group):
group.variables.add_array(
dim_name,
diff --git a/cleo/ephys/__init__.py b/cleo/ephys/__init__.py
index 3a9f9ca..9cca0cb 100644
--- a/cleo/ephys/__init__.py
+++ b/cleo/ephys/__init__.py
@@ -1,13 +1,19 @@
"""Contains probes, convenience functions for generating electrode array coordinates,
signals, spiking, and LFP"""
-from cleo.ephys.lfp import TKLFPSignal
-from cleo.ephys.spiking import MultiUnitSpiking, SortedSpiking, Spiking
+from cleo.ephys.lfp import (
+ LFPSignalBase,
+ RWSLFPSignalBase,
+ RWSLFPSignalFromPSCs,
+ RWSLFPSignalFromSpikes,
+ TKLFPSignal,
+)
from cleo.ephys.probes import (
Probe,
Signal,
linear_shank_coords,
- tetrode_shank_coords,
poly2_shank_coords,
poly3_shank_coords,
+ tetrode_shank_coords,
tile_coords,
)
+from cleo.ephys.spiking import MultiUnitSpiking, SortedSpiking, Spiking
diff --git a/cleo/ephys/lfp.py b/cleo/ephys/lfp.py
index cd81d0e..7eba408 100644
--- a/cleo/ephys/lfp.py
+++ b/cleo/ephys/lfp.py
@@ -1,39 +1,111 @@
"""Contains LFP signals"""
from __future__ import annotations
+import warnings
+from collections import deque
from datetime import datetime
-from typing import Any
+from itertools import chain
+from math import floor
+from numbers import Number
+from typing import Any, Union
-import numpy as np
+import neo
import quantities as pq
+import wslfp
from attrs import define, field
-from brian2 import NeuronGroup, mm, ms
+from brian2 import NeuronGroup, Quantity, Subgroup, Synapses, mm, ms, np, um
from brian2.monitors.spikemonitor import SpikeMonitor
+from brian2.synapses.synapses import SynapticSubgroup
+from brian2.units import Unit, uvolt
from nptyping import NDArray
+from scipy import sparse
from tklfp import TKLFP
import cleo.utilities
from cleo.base import NeoExportable
+from cleo.coords import coords_from_ng
from cleo.ephys.probes import Signal
+class LFPSignalBase(Signal, NeoExportable):
+ """Base class for LFP Signals.
+
+ Injection kwargs
+ ----------------
+ orientation : np.ndarray, optional
+ Array of shape (n_neurons, 3) representing which way is "up," that is, towards
+ the surface of the cortex, for each neuron. If a single vector is given, it is
+ taken to be the orientation for all neurons in the group. [0, 0, -1] is the
+ default, meaning the negative z axis is "up."
+ """
+
+ t_ms: NDArray[(Any,), float] = field(init=False, repr=False)
+ """Times at which LFP is recorded, in ms, stored if
+ :attr:`~cleo.InterfaceDevice.save_history` on :attr:`~Signal.probe`"""
+ lfp: Union[NDArray[(Any, Any), Quantity]] = field(init=False, repr=False)
+ """Approximated LFP from every call to :meth:`get_state`.
+ Shape is (n_samples, n_channels). Stored if
+ :attr:`~cleo.InterfaceDevice.save_history` on :attr:`~Signal.probe`"""
+ _elec_coords: np.ndarray = field(init=False, repr=False)
+ _lfp_unit: Unit
+
+ def _post_init_for_probe(self):
+ self._elec_coords = self.probe.coords.copy()
+ # need to invert z coords since cleo uses an inverted z axis and
+ # tklfp and wslfp do not
+ self._elec_coords[:, 2] *= -1
+ self._init_saved_vars()
+
+ def _init_saved_vars(self):
+ if self.probe.save_history:
+ self.t_ms = np.empty((0,))
+ self.lfp = np.empty((0, self.probe.n)) * self._lfp_unit
+
+ def _update_saved_vars(self, t_ms, lfp):
+ if self.probe.save_history:
+ # self.t_ms = np.concatenate([self.t_ms, [t_ms]])
+ # self.lfp = np.vstack([self.lfp, lfp])
+ lfp = np.reshape(lfp, (1, -1))
+ t_ms = np.reshape(t_ms, (1,))
+ self.t_ms = cleo.utilities.unit_safe_append(self.t_ms, t_ms)
+ self.lfp = cleo.utilities.unit_safe_append(self.lfp, lfp)
+
+ def to_neo(self) -> neo.AnalogSignal:
+ # inherit docstring
+ try:
+ signal = cleo.utilities.analog_signal(
+ self.t_ms,
+ self.lfp,
+ str(self._lfp_unit),
+ )
+ except AttributeError:
+ return
+ signal.name = self.probe.name + "." + self.name
+ signal.description = f"Exported from Cleo {self.__class__.__name__} object"
+ signal.annotate(export_datetime=datetime.now())
+ # broadcast in case of uniform direction
+ signal.array_annotate(
+ x=self.probe.coords[..., 0] / mm * pq.mm,
+ y=self.probe.coords[..., 1] / mm * pq.mm,
+ z=self.probe.coords[..., 2] / mm * pq.mm,
+ i_channel=np.arange(self.probe.n),
+ )
+ return signal
+
+
@define(eq=False)
-class TKLFPSignal(Signal, NeoExportable):
+class TKLFPSignal(LFPSignalBase):
"""Records the Teleńczuk kernel LFP approximation.
Requires ``tklfp_type='exc'|'inh'`` to specify cell type
on injection.
- An ``orientation`` keyword argument can also be specified on
- injection, which should be an array of shape ``(n_neurons, 3)``
- representing which way is "up," that is, towards the surface of
- the cortex, for each neuron. If a single vector is given, it is
- taken to be the orientation for all neurons in the group. [0, 0, -1]
- is the default, meaning the negative z axis is "up." As stated
- elsewhere, Cleo's convention is that z=0 corresponds to the
- cortical surface and increasing z values represent increasing depth.
-
TKLFP is computed from spikes using the `tklfp package `_.
+
+ Injection kwargs
+ ----------------
+ tklfp_type : str
+ Either 'exc' or 'inh' to specify the cell type.
"""
uLFP_threshold_uV: float = 1e-3
@@ -41,37 +113,13 @@ class TKLFPSignal(Signal, NeoExportable):
to be considered, by default 1e-3.
This determines the buffer length of past spikes, since the uLFP from a long-past
spike becomes negligible and is ignored."""
- t_ms: NDArray[(Any,), float] = field(init=False, repr=False)
- """Times at which LFP is recorded, in ms, stored if
- :attr:`~cleo.InterfaceDevice.save_history` on :attr:`~Signal.probe`"""
- lfp_uV: NDArray[(Any, Any), float] = field(init=False, repr=False)
- """Approximated LFP from every call to :meth:`get_state`.
- Shape is (n_samples, n_channels). Stored if
- :attr:`~cleo.InterfaceDevice.save_history` on :attr:`~Signal.probe`"""
- _elec_coords_mm: np.ndarray = field(init=False, repr=False)
_tklfps: list[TKLFP] = field(init=False, factory=list, repr=False)
_monitors: list[SpikeMonitor] = field(init=False, factory=list, repr=False)
_mon_spikes_already_seen: list[int] = field(init=False, factory=list, repr=False)
_i_buffers: list[list[np.ndarray]] = field(init=False, factory=list, repr=False)
_t_ms_buffers: list[list[np.ndarray]] = field(init=False, factory=list, repr=False)
_buffer_positions: list[int] = field(init=False, factory=list, repr=False)
-
- def _post_init_for_probe(self):
- self._elec_coords_mm = self.probe.coords / mm
- # need to invert z coords since cleo uses an inverted z axis and
- # tklfp does not
- self._elec_coords_mm[:, 2] *= -1
- self._init_saved_vars()
-
- def _init_saved_vars(self):
- if self.probe.save_history:
- self.t_ms = np.empty((0,))
- self.lfp_uV = np.empty((0, self.probe.n))
-
- def _update_saved_vars(self, t_ms, lfp_uV):
- if self.probe.save_history:
- self.t_ms = np.concatenate([self.t_ms, [t_ms]])
- self.lfp_uV = np.vstack([self.lfp_uV, lfp_uV])
+ _lfp_unit: Unit = uvolt
def connect_to_neuron_group(self, neuron_group: NeuronGroup, **kwparams):
# inherit docstring
@@ -90,7 +138,7 @@ def connect_to_neuron_group(self, neuron_group: NeuronGroup, **kwparams):
neuron_group.y / mm,
-neuron_group.z / mm, # invert neuron zs as well
is_excitatory=tklfp_type == "exc",
- elec_coords_mm=self._elec_coords_mm,
+ elec_coords_mm=self._elec_coords / mm,
orientation=orientation,
)
@@ -119,18 +167,16 @@ def get_state(self) -> np.ndarray:
for i_mon in range(len(self._monitors)):
self._update_spike_buffer(i_mon)
tot_tklfp += self._tklfp_for_monitor(i_mon, now_ms)
- out = np.reshape(tot_tklfp, (-1,)) # return 1D array (vector)
- self._update_saved_vars(now_ms, out)
- return out
+ tot_tklfp = np.reshape(tot_tklfp, (-1,)) * uvolt # return 1D array (vector)
+ self._update_saved_vars(now_ms, tot_tklfp)
+ return tot_tklfp
def reset(self, **kwargs) -> None:
- super(TKLFPSignal, self).reset(**kwargs)
for i_mon in range(len(self._monitors)):
self._reset_buffer(i_mon)
self._init_saved_vars()
def _reset_buffer(self, i_mon):
- mon = self._monitors[i_mon]
buf_len = len(self._i_buffers[i_mon])
self._i_buffers[i_mon] = [np.array([], dtype=int, ndmin=1)] * buf_len
self._t_ms_buffers[i_mon] = [np.array([], dtype=float, ndmin=1)] * buf_len
@@ -172,13 +218,96 @@ def _get_buffer_length(self, tklfp, **kwparams):
tklfp.compute_min_window_ms(self.uLFP_threshold_uV) / sample_period_ms
).astype(int)
+
+@define(eq=False)
+class RWSLFPSignalBase(LFPSignalBase):
+ """Base class for :class:`RWSLFPSignalFromSpikes` and :class:`RWSLFPSignalFromPSCs`.
+
+ These signals should only be injected into neurons representing pyramidal cells with
+ standard synaptic structure (see `Mazzoni, Lindén et al., 2015
+ `_).
+
+ RWSLFP is computed using the `wslfp package `_.
+
+ ``amp_func`` and ``pop_aggregate`` can be overridden on injection.
+ """
+
+ # note these set defaults that can be overrriden on injection
+ amp_func: callable = wslfp.mazzoni15_nrn
+ """Function to calculate LFP amplitudes, by default ``wslfp.mazzoni15_nrn``.
+
+ See `wslfp documentation `_ for more info."""
+ pop_aggregate: bool = False
+ """Whether to aggregate currents across the population (as opposed to neurons having
+ differential contributions to LFP depending on their location). False by default."""
+
+ _wslfps: dict[NeuronGroup, wslfp.WSLFPCalculator] = field(
+ init=False, factory=dict, repr=False
+ )
+ _lfp_unit: Unit = 1
+
+ def _init_wslfp_calc(self, neuron_group: NeuronGroup, **kwparams):
+ nrn_coords_um = coords_from_ng(neuron_group) / um
+ nrn_coords_um[:, 2] *= -1
+
+ orientation = np.copy(kwparams.pop("orientation", np.array([[0, 0, -1]])))
+ orientation = orientation.reshape((-1, 3))
+ assert np.shape(orientation)[-1] == 3
+ orientation[..., 2] *= -1
+
+ if self.pop_aggregate:
+ nrn_coords_um = np.mean(nrn_coords_um, axis=0)
+ orientation = np.mean(orientation, axis=0)
+
+ wslfp_kwargs = {}
+ for key in [
+ "source_coords_are_somata",
+ "source_dendrite_length_um",
+ "amp_kwargs",
+ "alpha",
+ "tau_ampa_ms",
+ "tau_gaba_ms",
+ "strict_boundaries",
+ ]:
+ if key in kwparams:
+ wslfp_kwargs[key] = kwparams.pop(key)
+
+ self._wslfps[neuron_group] = wslfp.from_xyz_coords(
+ self._elec_coords / um,
+ nrn_coords_um,
+ amp_func=kwparams.pop("amp_func", self.amp_func),
+ source_orientation=orientation,
+ **wslfp_kwargs,
+ )
+
+ def get_state(self) -> np.ndarray:
+ # round to avoid floating point errors
+ now_ms = round(self.probe.sim.network.t / ms, 3)
+ lfp = np.zeros((1, self.probe.n))
+ for ng, wslfp_calc in self._wslfps.items():
+ t_ampa_ms = now_ms - wslfp_calc.tau_ampa_ms
+ t_gaba_ms = now_ms - wslfp_calc.tau_gaba_ms
+ I_ampa, I_gaba = self._needed_current(ng, t_ampa_ms, t_gaba_ms)
+ lfp += wslfp_calc.calculate(
+ [now_ms], t_ampa_ms, I_ampa, t_gaba_ms, I_gaba, normalize=False
+ )
+ out = np.reshape(lfp, (-1,)) # return 1D array (vector)
+ self._update_saved_vars(now_ms, out)
+ return out
+
+ def _needed_current(self, ng, t_ampa_ms: float, t_gaba_ms: float) -> np.ndarray:
+ """output must have shape (n_t, n_current_sources)"""
+ raise NotImplementedError
+
+ def reset(self, **kwargs) -> None:
+ self._init_saved_vars()
+
def to_neo(self) -> neo.AnalogSignal:
# inherit docstring
try:
signal = cleo.utilities.analog_signal(
self.t_ms,
- self.lfp_uV,
- "uV",
+ self.lfp,
)
except AttributeError:
return
@@ -193,3 +322,369 @@ def to_neo(self) -> neo.AnalogSignal:
i_channel=np.arange(self.probe.n),
)
return signal
+
+
+@define
+class SpikeToCurrentSource:
+ """Stores info needed to calculate synaptic currents from spikes for a given spike source."""
+
+ J: Union[np.ndarray, sparse.sparray]
+ mon: SpikeMonitor
+ biexp_kernel_params: dict[str, Any]
+
+
+@define(eq=False)
+class RWSLFPSignalFromSpikes(RWSLFPSignalBase):
+ """Computes RWSLFP from the spikes onto pyramidal cell.
+
+ Use this if your model does not simulate synaptic current dynamics directly.
+ The parameters of this class are used to synthesize biexponential synaptic currents
+ using ``wslfp.spikes_to_biexp_currents()``.
+ ``ampa_syns`` and ``gaba_syns`` are lists of Synapses or SynapticSubgroup objects
+ and must be passed as kwargs on injection, or else this signal will not be recorded
+ for the target neurons (useful for ignoring interneurons).
+ Attributes set on the signal object serve as the default, but can be overridden on injection.
+ Also, in the case that parameters (e.g., ``tau1_ampa`` or ``weight``) vary by synapse,
+ these can be overridden by passing a tuple of the Synapses or SynapticSubgroup object and
+ a dictionary of the parameters to override.
+
+ RWSLFP refers to the Reference Weighted Sum of synaptic currents LFP proxy from
+ `Mazzoni, Lindén et al., 2015 `_.
+
+ Injection kwargs
+ ----------------
+ ampa_syns : list[Synapses | SynapticSubgroup | tuple[Synapses|SynapticSubgroup, dict]]
+ Synapses or SynapticSubgroup objects representing AMPA synapses (delivering excitatory currents).
+ Or a tuple of the Synapses or SynapticSubgroup object and a dictionary of parameters to override.
+ gaba_syns : list[Synapses | SynapticSubgroup | tuple[Synapses|SynapticSubgroup, dict]]
+ Synapses or SynapticSubgroup objects representing GABA synapses (delivering inhibitory currents).
+ Or a tuple of the Synapses or SynapticSubgroup object and a dictionary of parameters to override.
+ weight : str | float, optional
+ Name of the weight variable or parameter in the Synapses or SynapticSubgroup objects, or a float
+ in the case of a single weight for all synapses. Default is 'w'.
+ """
+
+ # can override on injection: tau1|2_ampa|gaba, syn_delay, I_threshold
+ tau1_ampa: Quantity = 2 * ms
+ """The fall time constant of the biexponential current kernel for AMPA synapses.
+ 2 ms by default."""
+ tau2_ampa: Quantity = 0.4 * ms
+ """The time constant of subtracted part of the biexponential current kernel for AMPA synapses.
+ 0.4 ms by default."""
+ tau1_gaba: Quantity = 5 * ms
+ """The fall time constant of the biexponential current kernel for GABA synapses.
+ 5 ms by default."""
+ tau2_gaba: Quantity = 0.25 * ms
+ """The time constant of subtracted part of the biexponential current kernel for GABA synapses.
+ 0.25 ms by default."""
+ syn_delay: Quantity = 1 * ms
+ """The synaptic transmission delay, i.e., between a spike and the onset of the postsynaptic current.
+ 1 ms by default."""
+ I_threshold: float = 1e-3
+ """Threshold, as a proportion of the peak current, below which spikes' contribution
+ to synaptic currents (and thus LFP) is ignored, by default 1e-3."""
+ weight: str = "w"
+ """Name of the weight variable or parameter in the Synapses or SynapticSubgroup objects.
+ Default is 'w'."""
+ _ampa_sources: dict[NeuronGroup, dict[Synapses, SpikeToCurrentSource]] = field(
+ init=False, factory=dict, repr=False
+ )
+ _gaba_sources: dict[NeuronGroup, dict[Synapses, SpikeToCurrentSource]] = field(
+ init=False, factory=dict, repr=False
+ )
+
+ def _get_weight(self, syn, weight):
+ assert isinstance(weight, (Number, Quantity, str))
+ if isinstance(weight, (Number, Quantity)):
+ return weight
+
+ if isinstance(syn, Synapses):
+ syn_name = syn.name
+ if weight in syn.variables:
+ return getattr(syn, weight)
+ elif weight in syn.namespace:
+ return syn.namespace[weight]
+ elif isinstance(syn, SynapticSubgroup):
+ syn_name = syn.synapses.name
+ if weight in syn.synapses.variables:
+ return getattr(syn.synapses, weight)[syn._stored_indices]
+ elif weight in syn.synapses.namespace:
+ return syn.synapses.namespace[weight]
+
+ raise ValueError(
+ f"weight {weight} not found in {syn_name} variables or namespace"
+ )
+
+ def _create_spk2curr_source(self, syn, neuron_group, weight, biexp_kwparams):
+ # need source_ng, syn_i, syn_j
+ if isinstance(syn, Synapses):
+ source_ng = syn.source
+ syn_i, syn_j = syn.i, syn.j
+ elif isinstance(syn, SynapticSubgroup):
+ source_ng = syn.synapses.source
+ syn_i = syn.synapses.i[syn._stored_indices]
+ syn_j = syn.synapses.j[syn._stored_indices]
+ else:
+ raise TypeError(
+ "ampa_syns and gaba_syns only take Synapses or SynapticSubgroup objects"
+ )
+ mon = SpikeMonitor(source_ng, record=list(np.unique(syn_i)))
+ self.brian_objects.add(mon)
+
+ J = sparse.lil_array((source_ng.N, neuron_group.N))
+ w = self._get_weight(syn, weight)
+ J[syn_i, syn_j] = w
+ J = J.tocsr()
+ if self.pop_aggregate:
+ J = J.sum(axis=1).reshape((-1, 1))
+
+ return SpikeToCurrentSource(J, mon, biexp_kwparams)
+
+ def _process_syn(self, syn, kwparams) -> tuple[Synapses, dict]:
+ """handles the case when a tuple of Synapses, kwargs is passed in"""
+ if isinstance(syn, (tuple, list)):
+ syn, override_kwargs = syn
+ kwparams = {**kwparams, **override_kwargs}
+ else:
+ assert isinstance(syn, (Synapses, SynapticSubgroup))
+
+ return syn, kwparams
+
+ def connect_to_neuron_group(self, neuron_group: NeuronGroup, **kwparams):
+ # inherit docstring
+ # this dict structure should allow multiple injections with no problem;
+ # just the most recent injection will be used
+
+ # prep wslfp calculator object
+ if neuron_group not in self._wslfps:
+ self._init_wslfp_calc(neuron_group, **kwparams)
+
+ default_weight = kwparams.pop("weight", self.weight)
+ ampa_syns = kwparams.pop("ampa_syns", [])
+ gaba_syns = kwparams.pop("gaba_syns", [])
+
+ biexp_kwparams = {}
+ for key in [
+ "tau1_ampa",
+ "tau2_ampa",
+ "tau1_gaba",
+ "tau2_gaba",
+ "syn_delay",
+ "I_threshold",
+ ]:
+ biexp_kwparams[key] = kwparams.pop(key, getattr(self, key))
+
+ if neuron_group not in self._ampa_sources:
+ self._ampa_sources[neuron_group] = {}
+ self._gaba_sources[neuron_group] = {}
+ for ampa_syn in ampa_syns:
+ ampa_syn, updated_kwparams = self._process_syn(ampa_syn, biexp_kwparams)
+ weight = updated_kwparams.pop("weight", default_weight)
+ self._ampa_sources[neuron_group][ampa_syn] = self._create_spk2curr_source(
+ ampa_syn, neuron_group, weight, updated_kwparams
+ )
+ for gaba_syn in gaba_syns:
+ gaba_syn, updated_kwparams = self._process_syn(gaba_syn, biexp_kwparams)
+ weight = updated_kwparams.pop("weight", default_weight)
+ self._gaba_sources[neuron_group][gaba_syn] = self._create_spk2curr_source(
+ gaba_syn, neuron_group, weight, updated_kwparams
+ )
+
+ def _get_biexp_kwargs_from_s2cs(self, s2cs: SpikeToCurrentSource, syn_type: str):
+ # check overrides, fall back on Signal-level defaults
+ return {
+ "tau1_ms": s2cs.biexp_kernel_params.get(
+ f"tau1_{syn_type}", getattr(self, f"tau1_{syn_type}")
+ )
+ / ms,
+ "tau2_ms": s2cs.biexp_kernel_params.get(
+ f"tau2_{syn_type}", getattr(self, f"tau2_{syn_type}")
+ )
+ / ms,
+ "syn_delay_ms": s2cs.biexp_kernel_params.get("syn_delay", self.syn_delay)
+ / ms,
+ "threshold": s2cs.biexp_kernel_params.get("I_threshold", self.I_threshold),
+ }
+
+ def _needed_current(self, ng, t_ampa_ms: float, t_gaba_ms: float) -> np.ndarray:
+ """output must have shape (n_t, n_current_sources)"""
+ n_sources = 1 if self.pop_aggregate else ng.N
+ I_ampa = np.zeros((1, n_sources))
+ for ampa_src in self._ampa_sources[ng].values():
+ biexp_kwargs = self._get_biexp_kwargs_from_s2cs(ampa_src, "ampa")
+ I_ampa += wslfp.spikes_to_biexp_currents(
+ [t_ampa_ms],
+ ampa_src.mon.t / ms,
+ ampa_src.mon.i,
+ ampa_src.J,
+ **biexp_kwargs,
+ )
+
+ I_gaba = np.zeros((1, n_sources))
+ for gaba_src in self._gaba_sources[ng].values():
+ biexp_kwargs = self._get_biexp_kwargs_from_s2cs(gaba_src, "gaba")
+ I_gaba += wslfp.spikes_to_biexp_currents(
+ [t_gaba_ms],
+ gaba_src.mon.t / ms,
+ gaba_src.mon.i,
+ gaba_src.J,
+ **biexp_kwargs,
+ )
+
+ return I_ampa, I_gaba
+
+
+@define(eq=False)
+class RWSLFPSignalFromPSCs(RWSLFPSignalBase):
+ """Computes RWSLFP from the currents onto pyramidal cells.
+
+ Use this if your model already simulates synaptic current dynamics.
+ ``Iampa_var_names`` and ``Igaba_var_names`` are lists of variable names to include
+ and must be passed in as kwargs on injection or else the target neuron group will
+ not contribute to this signal (desirable for interneurons).
+
+ RWSLFP refers to the Reference Weighted Sum of synaptic currents LFP proxy from
+ `Mazzoni, Lindén et al., 2015 `_.
+
+ Injection kwargs
+ ----------------
+ Iampa_var_names : list[str]
+ List of variable names in the neuron group representing AMPA currents.
+ Igaba_var_names : list[str]
+ List of variable names in the neuron group representing GABA currents.
+ """
+
+ _ampa_vars: dict[NeuronGroup, list] = field(init=False, factory=dict, repr=False)
+ _gaba_vars: dict[NeuronGroup, list] = field(init=False, factory=dict, repr=False)
+ _t_ampa_bufs: dict[NeuronGroup, deque[float]] = field(
+ init=False, factory=dict, repr=False
+ )
+ _I_ampa_bufs: dict[NeuronGroup, deque[np.ndarray]] = field(
+ init=False, factory=dict, repr=False
+ )
+ _t_gaba_bufs: dict[NeuronGroup, deque[float]] = field(
+ init=False, factory=dict, repr=False
+ )
+ _I_gaba: dict[NeuronGroup, deque[np.ndarray]] = field(
+ init=False, factory=dict, repr=False
+ )
+
+ def connect_to_neuron_group(self, neuron_group: NeuronGroup, **kwparams):
+ # ^ is XOR
+ if ("Iampa_var_names" in kwparams) ^ ("Igaba_var_names" in kwparams):
+ raise ValueError(
+ "Iampa_var_names and Igaba_var_names must be included together."
+ )
+ if "Iampa_var_names" not in kwparams:
+ return
+
+ I_ampa_names = kwparams.pop("Iampa_var_names")
+ I_gaba_names = kwparams.pop("Igaba_var_names")
+ for varname in chain(I_ampa_names, I_gaba_names):
+ if not hasattr(neuron_group, varname):
+ raise ValueError(
+ f"NeuronGroup {neuron_group.name} does not have a variable {varname}"
+ )
+
+ # prep wslfp calculator object
+ if neuron_group in self._wslfps:
+ warnings.warn(
+ f"{self.name} previously connected to {neuron_group.name}."
+ " Reconnecting will overwrite previous connection."
+ )
+
+ self._init_wslfp_calc(neuron_group, **kwparams)
+
+ buf_len_ampa, buf_len_gaba = self._get_buf_lens(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)
+ self._I_gaba[neuron_group] = deque(maxlen=buf_len_gaba)
+
+ # add underscores to get values without units
+ 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):
+ # need sampling period
+ sample_period_ms = kwparams.get("sample_period_ms", None)
+ if sample_period_ms is None:
+ try:
+ sample_period_ms = self.probe.sim.io_processor.sample_period_ms
+ except AttributeError: # probably means sim doesn't have io_processor
+ raise Exception(
+ "RSWLFPSignalFromPSCs needs to know the sampling period."
+ " Either set the simulator's IO processor before injecting"
+ f" {self.probe.name} or "
+ 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)
+ 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:
+ return empty
+ # when tau is multiple of sample time, current should be collected
+ # right when needed, at the left end of the buffer
+ elif np.isclose(t_eval_ms, t_buf_ms[0]):
+ return I_buf[0]
+
+ # 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]
+ )
+
+ I_interp = np.reshape(I_interp, (1, n_sources))
+ I_interp = np.nan_to_num(I_interp, nan=0)
+ return I_interp
+
+ def _needed_current(
+ self, ng, t_ampa_ms, t_gaba_ms
+ ) -> tuple[np.ndarray, np.ndarray]:
+ """outputs must have shape (n_t, n_current_sources)"""
+ # First add current currents to history
+ # -- need to round to avoid floating point errors
+ now_ms = round(self.probe.sim.network.t / ms, 3)
+ self._t_ampa_bufs[ng].append(now_ms)
+ self._t_gaba_bufs[ng].append(now_ms)
+
+ I_ampa = np.zeros((1, ng.N))
+ for I_ampa_name in self._ampa_vars[ng]:
+ I_ampa += getattr(ng, I_ampa_name)
+
+ I_gaba = np.zeros((1, ng.N))
+ for I_gaba_name in self._gaba_vars[ng]:
+ I_gaba += getattr(ng, I_gaba_name)
+
+ if self.pop_aggregate:
+ I_ampa = np.sum(I_ampa)
+ I_gaba = np.sum(I_gaba)
+ self._I_ampa_bufs[ng].append(I_ampa)
+ self._I_gaba[ng].append(I_gaba)
+
+ # Then interpolate history to get currents at the requested times
+ n_sources = 1 if self.pop_aggregate else ng.N
+ I_ampa = self._curr_from_buffer(
+ self._t_ampa_bufs[ng], self._I_ampa_bufs[ng], t_ampa_ms, n_sources
+ )
+ I_gaba = self._curr_from_buffer(
+ self._t_gaba_bufs[ng], self._I_gaba[ng], t_gaba_ms, n_sources
+ )
+
+ return I_ampa, I_gaba
+
+ 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])
+ 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)
+ self._I_gaba[ng] = deque(maxlen=buf_len_gaba)
diff --git a/cleo/ephys/probes.py b/cleo/ephys/probes.py
index 43635e6..4577d67 100644
--- a/cleo/ephys/probes.py
+++ b/cleo/ephys/probes.py
@@ -113,6 +113,9 @@ def __attrs_post_init__(self):
"coords must be an n by 3 array (with unit) with x, y, and z"
"coordinates for n contact locations."
)
+ signal_names = [signal.name for signal in self.signals]
+ if len(signal_names) != len(set(signal_names)):
+ raise ValueError("Signal names must be unique")
for signal in self.signals:
signal.init_for_probe(self)
@@ -129,6 +132,10 @@ def add_signals(self, *signals: Signal) -> None:
*signals : Signal
signals to add
"""
+ signal_names = [signal.name for signal in self.signals]
+ signal_names.extend(signal.name for signal in signals)
+ if len(signal_names) != len(set(signal_names)):
+ raise ValueError("Signal names must be unique per Probe")
for signal in signals:
signal.init_for_probe(self)
self.signals.append(signal)
diff --git a/cleo/light/light_dependence.py b/cleo/light/light_dependence.py
index d74729d..979f8f4 100644
--- a/cleo/light/light_dependence.py
+++ b/cleo/light/light_dependence.py
@@ -79,7 +79,7 @@ def _get_source_for_synapse(
return light_agg_ng, list(range(len(i_targets)))
def epsilon(self, lambda_new) -> float:
- """Returns the :math:`\\varepsilon`` value for a given lambda (in nm)
+ """Returns the :math:`\\varepsilon` value for a given lambda (in nm)
representing the relative sensitivity of the opsin to that wavelength."""
action_spectrum = np.array(self.spectrum)
lambdas = action_spectrum[:, 0]
diff --git a/cleo/utilities.py b/cleo/utilities.py
index 5ed2566..a8f9b82 100644
--- a/cleo/utilities.py
+++ b/cleo/utilities.py
@@ -2,6 +2,7 @@
import warnings
from collections.abc import MutableMapping
+import brian2 as b2
import neo
import quantities as pq
from brian2 import Quantity, np, second
@@ -24,7 +25,7 @@ def times_are_regular(times):
return np.allclose(np.diff(times), times[1] - times[0])
-def analog_signal(t_ms, values_no_unit, units) -> neo.core.basesignal.BaseSignal:
+def analog_signal(t_ms, values_no_unit, units="") -> neo.core.basesignal.BaseSignal:
if times_are_regular(t_ms):
return neo.AnalogSignal(
values_no_unit,
@@ -292,3 +293,14 @@ def style_plots_for_docs(dark=True):
plt.rc("savefig", transparent=False)
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")
+ if isinstance(q1, Quantity):
+ assert isinstance(q2, Quantity)
+ unit = q1.get_best_unit()
+ return np.append(q1 / unit, q2 / unit, axis=axis) * unit
+ else:
+ return np.append(q1, q2, axis=axis)
diff --git a/cleo/viz.py b/cleo/viz.py
index 4a6bf49..636b54e 100644
--- a/cleo/viz.py
+++ b/cleo/viz.py
@@ -208,9 +208,9 @@ def _plot(
kwargs["color"] = colors[i]
kwargs.update(scatterargs)
neuron_artists.append(ax.scatter(*xyz, **kwargs))
- ax.set_xlabel(f"x ({axis_scale_unit._dispname})")
- ax.set_ylabel(f"y ({axis_scale_unit._dispname})")
- ax.set_zlabel(f"z ({axis_scale_unit._dispname})")
+ ax.set_xlabel(f"x [{axis_scale_unit._dispname}]")
+ ax.set_ylabel(f"y [{axis_scale_unit._dispname}]")
+ ax.set_zlabel(f"z [{axis_scale_unit._dispname}]")
xlim = ax.get_xlim() if xlim is None else xlim
ylim = ax.get_ylim() if ylim is None else ylim
diff --git a/docs/conf.py b/docs/conf.py
index bdad14a..1c52be4 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -19,7 +19,7 @@
# -- Project information -----------------------------------------------------
project = "Cleo"
-copyright = "2023"
+copyright = "2024"
author = "Kyle Johnsen, Nathan Cruzado"
@@ -35,6 +35,7 @@
"sphinx.ext.napoleon",
"sphinx.ext.intersphinx",
"sphinx.ext.viewcode",
+ "sphinx.ext.duration",
"sphinx_copybutton",
"sphinx-favicon",
"myst_nb",
diff --git a/docs/tutorials/advanced_lfp.ipynb b/docs/tutorials/advanced_lfp.ipynb
new file mode 100644
index 0000000..b662b0f
--- /dev/null
+++ b/docs/tutorials/advanced_lfp.ipynb
@@ -0,0 +1,527 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Advanced LFP\n",
+ "\n",
+ "Here we will demonstrate the diverse ways the different LFP proxies can be computed and compare them to each other."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "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(18010601)\n",
+ "np.random.seed(18010601)\n",
+ "rng = np.random.default_rng(18010601)\n",
+ "\n",
+ "cleo.utilities.style_plots_for_docs()\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": 2,
+ "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 += J_excit\",\n",
+ " delay=synaptic_delay,\n",
+ " namespace={\"tau_rsyn\": 0.4 * b2.ms, \"tau_dsyn\": 2 * b2.ms},\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 += J_inhib\",\n",
+ " delay=synaptic_delay,\n",
+ " namespace={\"tau_rsyn\": 0.25 * b2.ms, \"tau_dsyn\": 5 * b2.ms},\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_ext\",\n",
+ " delay=synaptic_delay,\n",
+ " namespace={\"tau_rsyn\": 0.4 * b2.ms, \"tau_dsyn\": 2 * b2.ms},\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": 3,
+ "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=(500, 0, 0) * b2.um\n",
+ ")\n",
+ "probe = cleo.ephys.Probe(elec_coords)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "