bluecellulab 2.6.67__tar.gz → 2.6.68__tar.gz

{bluecellulab-2.6.67 → bluecellulab-2.6.68}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bluecellulab
-Version: 2.6.67
+Version: 2.6.68
 Summary: Biologically detailed neural network simulations and analysis.
 Author: Blue Brain Project, EPFL
 License: Apache2.0

{bluecellulab-2.6.67 → bluecellulab-2.6.68}/bluecellulab/cell/core.py

@@ -47,6 +47,7 @@ from bluecellulab.stimulus.circuit_stimulus_definitions import SynapseReplay
 from bluecellulab.synapse import SynapseFactory, Synapse
 from bluecellulab.synapse.synapse_types import SynapseID
 from bluecellulab.type_aliases import HocObjectType, NeuronSection, SectionMapping
+from bluecellulab.cell.section_tools import currents_vars, section_to_variable_recording_str
 
 logger = logging.getLogger(__name__)
 
@@ -250,6 +251,10 @@ class Cell(InjectableMixin, PlottableMixin):
         else:
             self._default_disable_ttx()
 
+    @property
+    def ttx_enabled(self):
+        return getattr(self, "_ttx_enabled", False)
+
     def _default_enable_ttx(self) -> None:
         """Default enable_ttx implementation."""
         for section in self.sections.values():
@@ -782,7 +787,7 @@ class Cell(InjectableMixin, PlottableMixin):
         if section is None:
             section = self.soma
 
-        # Optional: validate before constructing the string
+        # validate before constructing the string
         seg = section(segx)
         if "." in variable:
             mech, var = variable.split(".", 1)
@@ -895,23 +900,41 @@ class Cell(InjectableMixin, PlottableMixin):
     def __del__(self):
         self.delete()
 
-
-def section_to_variable_recording_str(section, segx: float, variable: str) -> str:
-    """Build an evaluable NEURON pointer string for `add_recording`.
-
-    Accepts:
-      - top-level vars: "v", "ina", "ik", ...
-      - mechanism-scoped vars: "kca.gkca", "na3.m", "na3.h", ...
-
-    Returns examples:
-      neuron.h.soma[0](0.5)._ref_v
-      neuron.h.soma[0](0.5)._ref_ina
-      neuron.h.soma[0](0.5).kca._ref_gkca
-      neuron.h.dend[3](0.7).na3._ref_m
-    """
-    sec_name = section.name()
-    if "." in variable:
-        mech, var = variable.split(".", 1)
-        return f"neuron.h.{sec_name}({segx}).{mech}._ref_{var}"
-    else:
-        return f"neuron.h.{sec_name}({segx})._ref_{variable}"
+    def add_currents_recordings(
+        self,
+        section,
+        segx: float = 0.5,
+        *,
+        include_nonspecific: bool = True,
+        include_point_processes: bool = False,
+        dt: float | None = None,
+    ) -> list[str]:
+        """Record all available currents (ionic + optionally nonspecific) at
+        (section, segx)."""
+
+        # discover what’s available at this site
+        available = currents_vars(section)
+        chosen: list[str] = []
+
+        for name, meta in available.items():
+            kind = meta.get("kind")
+
+            if kind == "ionic_current":
+                self.add_variable_recording(name, section=section, segx=segx, dt=dt)
+                chosen.append(name)
+
+            elif kind == "nonspecific_current":
+                if not include_nonspecific:
+                    continue
+                # density-mech nonspecific currents
+                self.add_variable_recording(name, section=section, segx=segx, dt=dt)
+                chosen.append(name)
+
+            elif kind == "point_process_current":
+                if not include_point_processes:
+                    continue
+                # point process nonspecific currents
+                self.add_variable_recording(name, section=section, segx=segx, dt=dt)
+                chosen.append(name)
+
+        return chosen

bluecellulab-2.6.68/bluecellulab/cell/section_tools.py

@@ -0,0 +1,96 @@
+# Copyright 2025 Open Brain Institute
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""NEURON section helpers for BlueCelluLab."""
+
+
+def currents_vars(section) -> dict:
+    """Return recordable currents (with units) at a given section.
+
+    - Ionic currents from the ions block (e.g. ``ina``, ``ik``, ``ica``), in mA/cm².
+    - Mechanism currents for variables ``i`` or ``ihcn``, reported as ``<var>_<mech>``
+      (e.g. ``i_pas``, ``ihcn_Ih``), in mA/cm².
+
+    Args:
+        section: NEURON Section object.
+
+    Returns:
+        dict mapping variable names to {"units": str, "kind": str}.
+    """
+    psec = section.psection()
+    out = {}
+
+    ions = psec.get("ions", {}) or {}
+    for ion, vars_dict in ions.items():
+        if ion == "ttx":
+            continue
+        name = f"i{ion}"
+        if name in vars_dict:
+            out[name] = {"units": "mA/cm²", "kind": "ionic_current"}
+
+    special_currents = {
+        ("pas", "i"): "i_pas",
+        ("Ih", "ihcn"): "ihcn_Ih",
+        ("hd", "i"): "i_hd",
+    }
+
+    for (mech, var), out_name in special_currents.items():
+        if var in (psec.get("density_mechs") or {}).get(mech, {}):
+            out[out_name] = {"units": "mA/cm²", "kind": "nonspecific_current"}
+
+    return dict(sorted(out.items()))
+
+
+def mechs_vars(section, include_point_mechs: bool = False) -> dict:
+    """Return mechanism-scoped variables at a given section.
+
+    Args:
+        section: NEURON Section object.
+        include_point_mechs: Whether to include point processes.
+    """
+    psec = section.psection()
+    dens = psec.get("density_mechs", {}) or {}
+    points = psec.get("point_mechs", {}) or {}
+    mech_map = {
+        mech: sorted(vars_dict.keys())
+        for mech, vars_dict in dens.items() if vars_dict
+    }
+    entry = {"mech": mech_map}
+    if include_point_mechs:
+        point_map = {
+            pp: sorted(vars_dict.keys())
+            for pp, vars_dict in points.items() if vars_dict
+        }
+        entry["point"] = point_map
+    return entry
+
+
+def section_to_variable_recording_str(section, segx: float, variable: str) -> str:
+    """Build an evaluable NEURON pointer string for `add_recording`.
+
+    Accepts:
+      - top-level vars: "v", "ina", "ik", ...
+      - mechanism-scoped vars: "kca.gkca", "na3.m", "na3.h", ...
+
+    Returns examples:
+      neuron.h.soma[0](0.5)._ref_v
+      neuron.h.soma[0](0.5)._ref_ina
+      neuron.h.soma[0](0.5).kca._ref_gkca
+      neuron.h.dend[3](0.7).na3._ref_m
+    """
+    sec_name = section.name()
+    if "." in variable:
+        mech, var = variable.split(".", 1)
+        return f"neuron.h.{sec_name}({segx}).{mech}._ref_{var}"
+    else:
+        return f"neuron.h.{sec_name}({segx})._ref_{variable}"

{bluecellulab-2.6.67 → bluecellulab-2.6.68}/bluecellulab/tools.py

@@ -632,108 +632,3 @@ def compute_memodel_properties(
     )
 
     return {"holding_current": holding_current, "rheobase": rheobase, "rin": rin}
-
-
-def list_segment_ion_variables(cell, xs=(0.5,)):
-    """Enumerate top-level ionic variables (e.g. v, ina, ik, gna) available for
-    each section at specified segment locations.
-
-    Includes:
-      - Membrane potential (v)
-      - Standard ionic currents (ina, ik, ica, icl)
-      - Reversal potentials (ena, ek, eca, ecl)
-      - Conductances if exposed (gna, gk, gca, gcl)
-    """
-    out = {}
-    for sec in cell.sections.values():
-        xmap = {}
-        for x in xs:
-            seg = sec(x)
-
-            vars_ = []
-            # voltage always there
-            if hasattr(seg, "_ref_v"):
-                vars_.append("v")
-
-            # ionic currents (present if mechanisms with ions are inserted)
-            for ion in ("na", "k", "ca", "cl"):
-                if hasattr(seg, f"_ref_i{ion}"):
-                    vars_.append(f"i{ion}")
-                if hasattr(seg, f"_ref_e{ion}"):
-                    vars_.append(f"e{ion}")
-                if hasattr(seg, f"_ref_g{ion}"):
-                    vars_.append(f"g{ion}")
-
-            xmap[float(x)] = sorted(set(vars_))
-
-        out[sec.name()] = xmap
-    return out
-
-
-def list_segment_mechanism_variables(cell, xs=(0.5,), include_point_mechs=False):
-    """Enumerate mechanism-scoped recordables per section/segment.
-
-    Returns:
-        dict: A nested dictionary of the form::
-
-            {
-                "<secname>": {
-                    x: {
-                        "mech": {
-                            "<density_mech>": [<vars>],
-                            ...
-                        },
-                        "point": {
-                            "<point_mech>": [<vars>],
-                            ...
-                        }  # present only if include_point_mechs
-                    },
-                    ...
-                },
-                ...
-            }
-    """
-    out = {}
-    for sec in cell.sections.values():
-        dens = sec.psection().get("density_mechs", {}) or {}
-        points = sec.psection().get("point_mechs", {}) or {}
-        xmap = {}
-
-        for x in xs:
-            seg = sec(x)
-
-            # Density mechanisms
-            mech_map = {}
-            for mech, vardict in dens.items():
-                mobj = getattr(seg, mech, None)
-                if mobj is None:
-                    continue
-                # take var names advertised by psection(), keep those that are actually _ref_-exposed
-                vars_found = sorted(
-                    v for v in vardict.keys()
-                    if hasattr(mobj, f"_ref_{v}")
-                )
-                if vars_found:
-                    mech_map[mech] = vars_found
-
-            entry = {"mech": mech_map}
-
-            # Point processes
-            if include_point_mechs:
-                pp_map = {}
-                for pp, vardict in points.items():
-                    pobj = getattr(seg, pp, None)
-                    if pobj is None:
-                        continue
-                    vars_found = sorted(
-                        v for v in vardict.keys()
-                        if hasattr(pobj, f"_ref_{v}")
-                    )
-                    if vars_found:
-                        pp_map[pp] = vars_found
-                entry["point"] = pp_map
-
-            xmap[float(x)] = entry
-
-        out[sec.name()] = xmap
-    return out

{bluecellulab-2.6.67 → bluecellulab-2.6.68}/bluecellulab.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bluecellulab
-Version: 2.6.67
+Version: 2.6.68
 Summary: Biologically detailed neural network simulations and analysis.
 Author: Blue Brain Project, EPFL
 License: Apache2.0

{bluecellulab-2.6.67 → bluecellulab-2.6.68}/bluecellulab.egg-info/SOURCES.txt

@@ -51,6 +51,7 @@ bluecellulab/cell/plotting.py
 bluecellulab/cell/random.py
 bluecellulab/cell/recording.py
 bluecellulab/cell/section_distance.py
+bluecellulab/cell/section_tools.py
 bluecellulab/cell/serialized_sections.py
 bluecellulab/cell/sonata_proxy.py
 bluecellulab/cell/stimuli_generator.py