Fix spiking functionality and sample period handling (#70)

* make spiking work when no neurons are recorded

* fix bug where sample period couldn't be passed in for RWSLFPSignalFromPSCs

* Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

* Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

* Avoid mutable default for inject_kwargs in RWSLFP test helper

* bump tklfp dependency

---------

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>
Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>

Author: 3 people

cleo/ephys/lfp.py

@@ -612,7 +612,7 @@ 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_for_wslfp(
-            self._wslfps[neuron_group]
+            self._wslfps[neuron_group], **kwparams
         )
         self._t_ampa_bufs[neuron_group] = deque(maxlen=buf_len_ampa)
         self._I_ampa_bufs[neuron_group] = deque(maxlen=buf_len_ampa)
@@ -633,8 +633,8 @@ def _get_buf_lens_for_wslfp(self, wslfp_calc, **kwparams):
             try:
                 sample_period = self.probe.sim.io_processor.sample_period
             except AttributeError:  # probably means sim doesn't have io_processor
-                raise Exception(
-                    "RSWLFPSignalFromPSCs needs to know the sampling period."
+                raise RuntimeError(
+                    "RWSLFPSignalFromPSCs 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}"

cleo/ephys/spiking.py

@@ -245,6 +245,12 @@ def connect_to_neuron_group(self, neuron_group: NeuronGroup, **kwparams):
         # spike sorters don't sort by multi-channel recall; we only do this
         # for computational efficiency, to not get super distant neurons
 
+        # needed even if no neurons are recorded
+        if not self._prev_t:
+            self._prev_t = self.probe.sim.network.t
+        if self._mu_eap is None:
+            self._mu_eap = np.zeros((0, self.n_channels))
+
         n2keep = np.sum(where_to_keep)
         if n2keep == 0:
             warnings.warn(
@@ -271,14 +277,8 @@ def connect_to_neuron_group(self, neuron_group: NeuronGroup, **kwparams):
         assert len(self.i_ng_by_i_probe) == i_probe_start
         self.i_ng_by_i_probe.extend(list(zip([neuron_group] * n2keep, i2keep)))
 
-        if not self._prev_t:
-            self._prev_t = self.probe.sim.network.t
-
         # store neuron-channel mean and stdev of EAPs to use in subclasses
-        if self._mu_eap is None:
-            self._mu_eap = snr[where_to_keep]
-        else:
-            self._mu_eap = np.concatenate((self._mu_eap, snr[where_to_keep]), axis=0)
+        self._mu_eap = np.concatenate((self._mu_eap, snr[where_to_keep]), axis=0)
 
         return snr[where_to_keep].max(axis=1), new_i_probe
 
@@ -642,7 +642,11 @@ def sorted_units_snr(self) -> Float[np.ndarray, "{self.n_sorted}"]:
         return self._mu_eap[self._i_probe_by_i_sorted]
 
     def connect_to_neuron_group(self, neuron_group, **kwparams):
-        snr, i_probe = super().connect_to_neuron_group(neuron_group, **kwparams)
+        connect_result = super().connect_to_neuron_group(neuron_group, **kwparams)
+        if connect_result is None:
+            # No neurons with high-enough multi-channel recall to record
+            return
+        snr, i_probe = connect_result
         n_recorded_ng = len(snr)
         # filter by SNR (measured on peak channel)
         above_cutoff = snr >= self.snr_cutoff

pyproject.toml

@@ -18,7 +18,7 @@ dependencies = [
     "scipy>=1.7.2,<1.14.1; python_version<'3.13'",
     "scipy>=1.14.1; python_version>='3.13'",
     "numpy >= 2.1.0,<3.0.0; python_version>='3.13'",
-    "tklfp>=0.2,<0.3",
+    "tklfp>=0.3,<0.4",
     "attrs>=23.0,<24.0",
     "neo>=0.12.0,<0.13.0",
     "wslfp>=0.2.1,<0.3.0",

tests/ephys/test_lfp.py

@@ -369,7 +369,10 @@ def add_rwslfp_sig(
         Iampa_var_names=["Iampa1"],
         Igaba_var_names=["Igaba1"],
         name=None,
+        inject_kwargs=None,
     ):
+        if inject_kwargs is None:
+            inject_kwargs = {}
         rwslfp_sig = RWSLFPSignalFromPSCs(
             pop_aggregate=pop_agg,
             amp_func=amp_func,
@@ -387,6 +390,7 @@ def add_rwslfp_sig(
             orientation=ornt,
             Iampa_var_names=Iampa_var_names,
             Igaba_var_names=Igaba_var_names,
+            **inject_kwargs,
         )
         return rwslfp_sig
 
@@ -416,6 +420,12 @@ def add_rwslfp_sig(
                     f"{sig1.name} and {sig2.name} not yielding different results"
                 )
 
+    # test missing sampling period error
+    sim.set_io_processor(None)
+    with pytest.raises(RuntimeError, match="needs to know the sampling period"):
+        add_rwslfp_sig()
+    add_rwslfp_sig(inject_kwargs={"sample_period": 5 * ms})
+
 
 def test_psc_buffer():
     sig = RWSLFPSignalFromPSCs()

tests/ephys/test_spiking.py

@@ -530,6 +530,26 @@ def test_cutoff(rand_seed):
     )
 
 
+def test_no_neurons():
+    """When neurons are too far away to be picked up at all."""
+    sgg = spike_generator_group([9000, 9001, 9002] * mm, period=1 * ms)
+    sim = CLSimulator(Network(sgg))
+    assert hasattr(sim, "network")
+    ss = SortedSpiking()
+    mua = MultiUnitActivity()
+    probe = Probe([0, 0, 0] * um, [ss, mua])
+    sim.inject(probe, sgg)
+    sim.run(10 * ms)
+    probe.get_state()
+    sim.run(10 * ms)
+    probe.get_state()
+    for sig in [ss, mua]:
+        assert len(sig.i) == 0
+        assert len(sig.t) == 0
+        assert len(sig.t_samp) == 0
+        assert sig.n_neurons == 0
+
+
 def _test_spiking_to_neo(spike_signal_class):
     spike_sig = spike_signal_class()
     n_channels = 50