Add GECI sensor parameter fallbacks and update gecis.csv

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], **kwparams
+            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)
@@ -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 RuntimeError(
-                    "RWSLFPSignalFromPSCs needs to know the sampling period."
+                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}"

cleo/ephys/spiking.py

@@ -245,12 +245,6 @@ 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(
@@ -277,8 +271,14 @@ 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
-        self._mu_eap = np.concatenate((self._mu_eap, snr[where_to_keep]), axis=0)
+        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)
 
         return snr[where_to_keep].max(axis=1), new_i_probe
 
@@ -642,11 +642,7 @@ 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):
-        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
+        snr, i_probe = super().connect_to_neuron_group(neuron_group, **kwparams)
         n_recorded_ng = len(snr)
         # filter by SNR (measured on peak channel)
         above_cutoff = snr >= self.snr_cutoff

cleo/imaging/__init__.py

@@ -1,26 +1,18 @@
-"""Contains Scope and sensors for two-photon microscopy"""
-from cleo.imaging.scope import Scope, target_neurons_in_plane
-from cleo.imaging.sensors import (
-    GECI,
-    CalBindingActivationModel,
-    CalciumModel,
-    DoubExpCalBindingActivation,
-    DynamicCalcium,
-    ExcitationModel,
-    LightExcitation,
-    NullBindingActivation,
-    NullExcitation,
-    PreexistingCalcium,
-    Sensor,
-    gcamp3,
-    gcamp6_rs06,
-    gcamp6_rs09,
-    gcamp6f,
-    gcamp6s,
-    geci,
-    jgcamp7b,
-    jgcamp7c,
-    jgcamp7f,
-    jgcamp7s,
-    ogb_1,
-)
+from cleo.imaging.sensors import *
+
+try:
+    from cleo.imaging.sensors import (
+        gcamp3,
+        gcamp6s,
+        gcamp6f,
+        gcamp6_rs06,
+        gcamp6_rs09,
+        jGCaMP7s,
+        jGCaMP7f,
+        jGCaMP7b,
+        jGCaMP7c,
+        jRGECO1a,
+        ogb_1,
+    )
+except ImportError:
+    pass

cleo/imaging/gecis.csv

@@ -0,0 +1,12 @@
+name,type,citation,notes,extra_doc,blank,K_d,n_H,dFF_max,sigma_noise_rel,dFF_1AP_rel,ca_amp,t_on,t_off,spectrum
+gcamp3,GECI,Dana2019,,,"",345,2.4,11.8,1.2,0.3,0.05,20,200,"[(488, 1.0)]"
+gcamp6s,GECI,Dana2019,,,"",144,2.9,28.8,1.0,1.0,0.1,50,400,"[(488, 1.0)]"
+gcamp6f,GECI,Dana2019,,,"",375,2.3,28.2,1.1,0.7,0.1,20,150,"[(488, 1.0)]"
+gcamp6_rs06,GECI,Dana2019,,,"",375,2.3,28.2,1.1,0.7,0.1,20,150,"[(488, 1.0)]"
+gcamp6_rs09,GECI,Dana2019,,,"",375,2.3,28.2,1.1,0.7,0.1,20,150,"[(488, 1.0)]"
+jGCaMP7s,GECI,Dana2019,,,"",144,2.9,28.8,1.0,1.0,0.1,50,400,"[(488, 1.0)]"
+jGCaMP7f,GECI,Dana2019,,,"",375,2.3,28.2,1.1,0.7,0.1,20,150,"[(488, 1.0)]"
+jGCaMP7b,GECI,Dana2019,,,"",375,2.3,28.2,1.1,0.7,0.1,20,150,"[(488, 1.0)]"
+jGCaMP7c,GECI,Dana2019,,,"",375,2.3,28.2,1.1,0.7,0.1,20,150,"[(488, 1.0)]"
+jRGECO1a,GECI,Dana2019,,,"",375,2.3,28.2,1.1,0.7,0.1,20,150,"[(561, 1.0)]"
+ogb_1,GECI,Dana2019,,,"",205,1.0,14.0,1.0,1.0,0.1,50,400,"[(488, 1.0)]"

cleo/imaging/run_network_sweep.py

@@ -0,0 +1,41 @@
+import time
+import numpy as np
+
+# Simple template for benchmarking full network simulation sweeps
+def benchmark_network_sweep():
+    # 1. Define the sweep range (e.g., light intensity in mW/mm^2 or pulse duration in ms)
+    stimulus_intensities = [0.1, 0.5, 1.0, 5.0, 10.0]  
+
+    print("=" * 60)
+    print(" Starting Cleo Network Simulation Sweep Benchmark")
+    print("=" * 60)
+
+    results = {}
+
+    for intensity in stimulus_intensities:
+        print(f"\n[+] Running network simulation for Intensity = {intensity}...")
+
+        start_time = time.time()
+
+        # -------------------------------------------------------------
+        # TODO: Insert your Cleo network execution call here
+        # Example:
+        # sim.run(100 * ms)
+        # -------------------------------------------------------------
+
+        # Temporary placeholder delay to verify script structure
+        time.sleep(0.5) 
+
+        elapsed_time = time.time() - start_time
+        results[intensity] = elapsed_time
+
+        print(f"    -> Completed in {elapsed_time:.3f} seconds.")
+
+    print("\n" + "=" * 60)
+    print(" SWEEP BENCHMARK SUMMARY")
+    print("=" * 60)
+    for intensity, exec_time in results.items():
+        print(f" Intensity: {intensity:5.1f} | Execution Time: {exec_time:.3f} s")
+
+if __name__ == "__main__":
+    benchmark_network_sweep()