bluecellulab 2.4.0__tar.gz → 2.4.1__tar.gz

{bluecellulab-2.4.0 → bluecellulab-2.4.1}/CHANGELOG.rst

@@ -1,6 +1,13 @@
 Changelog
 ==========
 
+2.4.1
+------
+
+* add analysis/inject_sequence.py to inject multiple stim to the same cell in isolation
+* core.py:: rename attribute 'all' to 'sections'
+* have a class TemplateParams to represent all template related values
+
 2.4.0
 ------
 

bluecellulab-2.4.1/Makefile

@@ -0,0 +1,6 @@
+clean:
+	rm -f .coverage
+	rm -f coverage.xml
+	rm -f *.nrndat
+	rm -f .coverage.*
+	rm -f python.*.btr

{bluecellulab-2.4.0 → bluecellulab-2.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bluecellulab
-Version: 2.4.0
+Version: 2.4.1
 Summary: The Pythonic Blue Brain simulator access
 Home-page: https://github.com/BlueBrain/BlueCelluLab
 Author: Blue Brain Project, EPFL

bluecellulab-2.4.1/bluecellulab/analysis/inject_sequence.py

@@ -0,0 +1,130 @@
+"""Module for injecting a sequence of protocols to the cell."""
+from __future__ import annotations
+from enum import Enum, auto
+from typing import NamedTuple, Sequence, Dict
+
+import neuron
+import numpy as np
+from bluecellulab.cell.core import Cell
+from bluecellulab.cell.template import TemplateParams
+from bluecellulab.simulation.simulation import Simulation
+from bluecellulab.stimulus.factory import Stimulus, StimulusFactory
+from bluecellulab.utils import IsolatedProcess
+
+
+class StimulusName(Enum):
+    """Allowed values for the StimulusName."""
+    AP_WAVEFORM = auto()
+    IDREST = auto()
+    IV = auto()
+    FIRE_PATTERN = auto()
+
+
+class Recording(NamedTuple):
+    """A tuple of the current, voltage and time recordings."""
+    current: np.ndarray
+    voltage: np.ndarray
+    time: np.ndarray
+
+
+StimulusRecordings = Dict[str, Recording]
+
+
+def run_stimulus(
+    template_params: TemplateParams,
+    stimulus: Stimulus,
+    section: str,
+    segment: float,
+    duration: float,
+) -> Recording:
+    """Creates a cell and stimulates it with a given stimulus.
+
+    Args:
+        template_params: The parameters to create the cell from a template.
+        stimulus: The input stimulus to inject into the cell.
+        section: Name of the section of cell where the stimulus is to be injected.
+        segment: The segment of the section where the stimulus is to be injected.
+        duration: The duration for which the simulation is to be run.
+
+    Returns:
+        The voltage-time recording at the specified location.
+
+    Raises:
+        ValueError: If the time and voltage arrays are not the same length.
+    """
+    cell = Cell.from_template_parameters(template_params)
+    neuron_section = cell.sections[section]
+    cell.add_voltage_recording(neuron_section, segment)
+    iclamp, _ = cell.inject_current_waveform(
+        stimulus.time, stimulus.current, section=neuron_section, segx=segment
+    )
+    current_vector = neuron.h.Vector()
+    current_vector.record(iclamp._ref_i)
+    simulation = Simulation(cell)
+    simulation.run(duration)
+    current = np.array(current_vector.to_python())
+    voltage = cell.get_voltage_recording(neuron_section, segment)
+    time = cell.get_time()
+    if len(time) != len(voltage) or len(time) != len(current):
+        raise ValueError("Time, current and voltage arrays are not the same length")
+    return Recording(current, voltage, time)
+
+
+def apply_multiple_step_stimuli(
+    cell: Cell,
+    stimulus_name: StimulusName,
+    amplitudes: Sequence[float],
+    duration: float,
+    section_name: str | None = None,
+    segment: float = 0.5,
+    n_processes: int | None = None,
+) -> StimulusRecordings:
+    """Apply multiple stimuli to the cell on isolated processes.
+
+    Args:
+        cell: The cell to which the stimuli are applied.
+        stimulus_name: The name of the stimulus to apply.
+        amplitudes: The amplitudes of the stimuli to apply.
+        duration: The duration for which each stimulus is applied.
+        section_name: Section name of the cell where the stimuli are applied.
+          If None, the stimuli are applied at the soma[0] of the cell.
+        segment: The segment of the section where the stimuli are applied.
+        n_processes: The number of processes to use for running the stimuli.
+
+    Returns:
+        A dictionary where the keys are the names of the stimuli and the values
+        are the recordings of the cell's response to each stimulus.
+
+    Raises:
+        ValueError: If the stimulus name is not recognized.
+    """
+    res: StimulusRecordings = {}
+    stim_factory = StimulusFactory(dt=1.0)
+    task_args = []
+    section_name = section_name if section_name is not None else "soma[0]"
+
+    # Prepare arguments for each stimulus
+    for amplitude in amplitudes:
+        if stimulus_name == StimulusName.AP_WAVEFORM:
+            stimulus = stim_factory.ap_waveform(threshold_current=cell.threshold, threshold_percentage=amplitude)
+        elif stimulus_name == StimulusName.IDREST:
+            stimulus = stim_factory.idrest(threshold_current=cell.threshold, threshold_percentage=amplitude)
+        elif stimulus_name == StimulusName.IV:
+            stimulus = stim_factory.iv(threshold_current=cell.threshold, threshold_percentage=amplitude)
+        elif stimulus_name == StimulusName.FIRE_PATTERN:
+            stimulus = stim_factory.fire_pattern(threshold_current=cell.threshold, threshold_percentage=amplitude)
+        else:
+            raise ValueError("Unknown stimulus name.")
+
+        task_args.append((cell.template_params, stimulus, section_name, segment, duration))
+
+    with IsolatedProcess(processes=n_processes) as pool:
+        # Map expects a function and a list of argument tuples
+        results = pool.starmap(run_stimulus, task_args)
+
+    # Associate each result with a key
+    for amplitude, result in zip(amplitudes, results):
+        key = f"{stimulus_name}_{amplitude}"
+        res[key] = result
+
+    return res

{bluecellulab-2.4.0 → bluecellulab-2.4.1}/bluecellulab/cell/core.py

@@ -27,12 +27,13 @@ import numpy as np
 import pandas as pd
 
 import bluecellulab
+from bluecellulab.cell.recording import section_to_voltage_recording_str
 from bluecellulab.psection import PSection, init_psections
 from bluecellulab.cell.injector import InjectableMixin
 from bluecellulab.cell.plotting import PlottableMixin
 from bluecellulab.cell.section_distance import EuclideanSectionDistance
 from bluecellulab.cell.sonata_proxy import SonataProxy
-from bluecellulab.cell.template import NeuronTemplate, public_hoc_cell
+from bluecellulab.cell.template import NeuronTemplate, TemplateParams, public_hoc_cell
 from bluecellulab.circuit.config.sections import Conditions
 from bluecellulab.circuit import EmodelProperties, SynapseProperty
 from bluecellulab.circuit.node_id import CellId
@@ -44,7 +45,7 @@ from bluecellulab.rngsettings import RNGSettings
 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
+from bluecellulab.type_aliases import HocObjectType, NeuronSection, SectionMapping
 
 logger = logging.getLogger(__name__)
 
@@ -54,6 +55,24 @@ class Cell(InjectableMixin, PlottableMixin):
 
     last_id = 0
 
+    @classmethod
+    def from_template_parameters(
+        cls, template_params: TemplateParams, cell_id: Optional[CellId] = None,
+        record_dt: Optional[float] = None
+    ) -> Cell:
+        """Create a cell from a TemplateParams object.
+
+        Useful in isolating runs.
+        """
+        return cls(
+            template_path=template_params.template_filepath,
+            morphology_path=template_params.morph_filepath,
+            cell_id=cell_id,
+            record_dt=record_dt,
+            template_format=template_params.template_format,
+            emodel_properties=template_params.emodel_properties,
+        )
+
     @load_hoc_and_mod_files
     def __init__(self,
                  template_path: str | Path,
@@ -73,6 +92,12 @@ class Cell(InjectableMixin, PlottableMixin):
             emodel_properties: Template specific emodel properties.
         """
         super().__init__()
+        self.template_params = TemplateParams(
+            template_filepath=template_path,
+            morph_filepath=morphology_path,
+            template_format=template_format,
+            emodel_properties=emodel_properties,
+        )
         if cell_id is None:
             cell_id = CellId("", Cell.last_id)
             Cell.last_id += 1
@@ -86,17 +111,16 @@ class Cell(InjectableMixin, PlottableMixin):
             if emodel_properties is None:
                 raise BluecellulabError('EmodelProperties must be provided for v6 template')
             self.hypamp: float | None = emodel_properties.holding_current
-            self.threshold: float | None = emodel_properties.threshold_current
+            self.threshold: float = emodel_properties.threshold_current
         else:
             try:
                 self.hypamp = self.cell.getHypAmp()
             except AttributeError:
                 self.hypamp = None
-
             try:
                 self.threshold = self.cell.getThreshold()
             except AttributeError:
-                self.threshold = None
+                self.threshold = 0.0
         self.soma = public_hoc_cell(self.cell).soma[0]
         # WARNING: this finitialize 'must' be here, otherwhise the
         # diameters of the loaded morph are wrong
@@ -131,6 +155,13 @@ class Cell(InjectableMixin, PlottableMixin):
         # as the object exists
         self.persistent: list[HocObjectType] = []
 
+    def _extract_sections(self, sections) -> SectionMapping:
+        res: SectionMapping = {}
+        for section in sections:
+            key_name = str(section).split(".")[-1]
+            res[key_name] = section
+        return res
+
     @property
     def somatic(self) -> list[NeuronSection]:
         return list(public_hoc_cell(self.cell).somatic)
@@ -148,8 +179,8 @@ class Cell(InjectableMixin, PlottableMixin):
         return list(public_hoc_cell(self.cell).axonal)
 
     @property
-    def all(self) -> list[NeuronSection]:
-        return list(public_hoc_cell(self.cell).all)
+    def sections(self) -> SectionMapping:
+        return self._extract_sections(public_hoc_cell(self.cell).all)
 
     def __repr__(self) -> str:
         base_info = f"Cell Object: {super().__repr__()}"
@@ -197,7 +228,7 @@ class Cell(InjectableMixin, PlottableMixin):
 
     def make_passive(self) -> None:
         """Make the cell passive by deactivating all the active channels."""
-        for section in self.all:
+        for section in self.sections.values():
             mech_names = set()
             for seg in section:
                 for mech in seg:
@@ -232,14 +263,14 @@ class Cell(InjectableMixin, PlottableMixin):
 
     def _default_enable_ttx(self) -> None:
         """Default enable_ttx implementation."""
-        for section in self.all:
+        for section in self.sections.values():
             if not neuron.h.ismembrane("TTXDynamicsSwitch"):
                 section.insert('TTXDynamicsSwitch')
             section.ttxo_level_TTXDynamicsSwitch = 1.0
 
     def _default_disable_ttx(self) -> None:
         """Default disable_ttx implementation."""
-        for section in self.all:
+        for section in self.sections.values():
             if not neuron.h.ismembrane("TTXDynamicsSwitch"):
                 section.insert('TTXDynamicsSwitch')
             section.ttxo_level_TTXDynamicsSwitch = 1e-14
@@ -247,7 +278,7 @@ class Cell(InjectableMixin, PlottableMixin):
     def area(self) -> float:
         """The total surface area of the cell."""
         area = 0.0
-        for section in self.all:
+        for section in self.sections.values():
             x_s = np.arange(1.0 / (2 * section.nseg), 1.0,
                             1.0 / (section.nseg))
             for x in x_s:
@@ -297,7 +328,7 @@ class Cell(InjectableMixin, PlottableMixin):
         self.add_recording("self.axonal[1](0.5)._ref_v", dt=dt)
 
     def add_voltage_recording(
-        self, section: "neuron.h.Section", segx: float = 0.5, dt: Optional[float] = None
+        self, section: Optional[NeuronSection] = None, segx: float = 0.5, dt: Optional[float] = None
     ) -> None:
         """Add a voltage recording to a certain section at a given segment
         (segx).
@@ -309,11 +340,13 @@ class Cell(InjectableMixin, PlottableMixin):
             dt: Recording time step. If not provided, the recording step will
                 default to the simulator's time step.
         """
-        var_name = f"neuron.h.{section.name()}({segx})._ref_v"
+        if section is None:
+            section = self.soma
+        var_name = section_to_voltage_recording_str(section, segx)
         self.add_recording(var_name, dt)
 
     def get_voltage_recording(
-        self, section: "neuron.h.Section", segx: float = 0.5
+        self, section: Optional[NeuronSection] = None, segx: float = 0.5
     ) -> np.ndarray:
         """Get a voltage recording for a certain section at a given segment
         (segx).
@@ -329,7 +362,9 @@ class Cell(InjectableMixin, PlottableMixin):
         Raises:
             BluecellulabError: If voltage recording was not added previously using add_voltage_recording.
         """
-        recording_name = f"neuron.h.{section.name()}({segx})._ref_v"
+        if section is None:
+            section = self.soma
+        recording_name = section_to_voltage_recording_str(section, segx)
         if recording_name in self.recordings:
             return self.get_recording(recording_name)
         else:
@@ -340,15 +375,13 @@ class Cell(InjectableMixin, PlottableMixin):
 
     def add_allsections_voltagerecordings(self):
         """Add a voltage recording to every section of the cell."""
-        all_sections = public_hoc_cell(self.cell).all
-        for section in all_sections:
+        for section in self.sections.values():
             self.add_voltage_recording(section, dt=self.record_dt)
 
     def get_allsections_voltagerecordings(self) -> dict[str, np.ndarray]:
         """Get all the voltage recordings from all the sections."""
         all_section_voltages = {}
-        all_sections = public_hoc_cell(self.cell).all
-        for section in all_sections:
+        for section in self.sections.values():
             recording = self.get_voltage_recording(section)
             all_section_voltages[section.name()] = recording
         return all_section_voltages
@@ -426,10 +459,10 @@ class Cell(InjectableMixin, PlottableMixin):
         """
         if location == "soma":
             sec = public_hoc_cell(self.cell).soma[0]
-            source = public_hoc_cell(self.cell).soma[0](1)._ref_v
+            source = sec(1)._ref_v
         elif location == "AIS":
             sec = public_hoc_cell(self.cell).axon[1]
-            source = public_hoc_cell(self.cell).axon[1](0.5)._ref_v
+            source = sec(0.5)._ref_v
         else:
             raise ValueError("Spike detection location must be soma or AIS")
         netcon = neuron.h.NetCon(source, target, sec=sec)
@@ -682,9 +715,10 @@ class Cell(InjectableMixin, PlottableMixin):
         """Get a vector of AIS voltage."""
         return self.get_recording('self.axonal[1](0.5)._ref_v')
 
-    def getNumberOfSegments(self) -> int:
+    @property
+    def n_segments(self) -> int:
         """Get the number of segments in the cell."""
-        return sum(section.nseg for section in self.all)
+        return sum(section.nseg for section in self.sections.values())
 
     def add_synapse_replay(
         self, stimulus: SynapseReplay, spike_threshold: float, spike_location: str

{bluecellulab-2.4.0 → bluecellulab-2.4.1}/bluecellulab/cell/injector.py

@@ -443,14 +443,14 @@ class InjectableMixin:
         time_vector = neuron.h.Vector().from_python(t_content)
         current_vector = neuron.h.Vector().from_python(i_content)
 
-        pulse = neuron.h.IClamp(segx, sec=section)
-        self.persistent.extend([pulse, time_vector, current_vector])
+        iclamp = neuron.h.IClamp(segx, sec=section)
+        self.persistent.extend([iclamp, time_vector, current_vector])
 
-        pulse.delay = t_content[0]
-        pulse.dur = t_content[-1] - t_content[0]
-        current_vector.play(pulse._ref_amp, time_vector)
+        iclamp.delay = t_content[0]
+        iclamp.dur = t_content[-1] - t_content[0]
+        current_vector.play(iclamp._ref_amp, time_vector)
 
-        return current_vector
+        return iclamp, current_vector
 
     @deprecated("Use add_sin_current instead.")
     def addSineCurrentInject(self, start_time, stop_time, freq,

bluecellulab-2.4.1/bluecellulab/cell/recording.py

@@ -0,0 +1,8 @@
+"""Neuron recordings related functions."""
+from __future__ import annotations
+from bluecellulab.type_aliases import NeuronSection
+
+
+def section_to_voltage_recording_str(section: NeuronSection, segment=0.5) -> str:
+    """Converts a section and segment to voltage recording string."""
+    return f"neuron.h.{section.name()}({segment})._ref_v"

{bluecellulab-2.4.0 → bluecellulab-2.4.1}/bluecellulab/cell/template.py

@@ -20,7 +20,7 @@ import os
 from pathlib import Path
 import re
 import string
-from typing import Optional
+from typing import NamedTuple, Optional
 
 import neuron
 
@@ -44,6 +44,13 @@ def public_hoc_cell(cell: HocObjectType) -> HocObjectType:
          from the hoc model. Either getCell() or CellRef needs to be provided""")
 
 
+class TemplateParams(NamedTuple):
+    template_filepath: str | Path
+    morph_filepath: str | Path
+    template_format: str
+    emodel_properties: Optional[EmodelProperties]
+
+
 class NeuronTemplate:
     """NeuronTemplate representation."""
 

{bluecellulab-2.4.0 → bluecellulab-2.4.1}/bluecellulab/type_aliases.py

@@ -1,5 +1,6 @@
 """Type aliases used within the package."""
-
+from __future__ import annotations
+from typing import Dict
 from typing_extensions import TypeAlias
 from neuron import h as hoc_type
 
@@ -8,3 +9,5 @@ NeuronRNG: TypeAlias = hoc_type
 NeuronVector: TypeAlias = hoc_type
 NeuronSection: TypeAlias = hoc_type
 TStim: TypeAlias = hoc_type
+
+SectionMapping = Dict[str, NeuronSection]

{bluecellulab-2.4.0 → bluecellulab-2.4.1}/bluecellulab/utils.py

@@ -50,5 +50,11 @@ class IsolatedProcess(Pool):
     Use this when running isolated NEURON simulations. Running 2 NEURON
     simulations on a single process is to be avoided.
     """
-    def __init__(self):
-        super().__init__(processes=1, maxtasksperchild=1)
+    def __init__(self, processes: int | None = 1):
+        """Initialize the IsolatedProcess pool.
+
+        Args:
+            processes: The number of processes to use for running the stimuli.
+            If set to None, then the number returned by os.cpu_count() is used.
+        """
+        super().__init__(processes=processes, maxtasksperchild=1)

{bluecellulab-2.4.0 → bluecellulab-2.4.1}/bluecellulab.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bluecellulab
-Version: 2.4.0
+Version: 2.4.1
 Summary: The Pythonic Blue Brain simulator access
 Home-page: https://github.com/BlueBrain/BlueCelluLab
 Author: Blue Brain Project, EPFL

{bluecellulab-2.4.0 → bluecellulab-2.4.1}/bluecellulab.egg-info/SOURCES.txt

@@ -37,12 +37,15 @@ bluecellulab.egg-info/SOURCES.txt
 bluecellulab.egg-info/dependency_links.txt
 bluecellulab.egg-info/requires.txt
 bluecellulab.egg-info/top_level.txt
+bluecellulab/analysis/__init__.py
+bluecellulab/analysis/inject_sequence.py
 bluecellulab/cell/__init__.py
 bluecellulab/cell/cell_dict.py
 bluecellulab/cell/core.py
 bluecellulab/cell/injector.py
 bluecellulab/cell/plotting.py
 bluecellulab/cell/random.py
+bluecellulab/cell/recording.py
 bluecellulab/cell/section_distance.py
 bluecellulab/cell/serialized_sections.py
 bluecellulab/cell/sonata_proxy.py
@@ -95,6 +98,7 @@ docs/source/_static/.gitkeep
 docs/source/logo/BlueCelluLabBanner.jpg
 examples/README.rst
 examples/readme-plot.ipynb
+examples/1-singlecell/README.md
 examples/1-singlecell/singlecell.ipynb
 examples/1-singlecell/hoc/cADpyr_L2TPC.hoc
 examples/1-singlecell/morphology/rr110330_C3_idA.asc
@@ -160,6 +164,7 @@ examples/4-epsp/hippocampus_mechanisms/na3n.mod
 examples/4-epsp/hoc/cell_seed2_0.hoc
 examples/4-epsp/morphology/011017HP2.asc
 examples/5-stimuli/stimuli.ipynb
+examples/6-stimuli-sequence/stimuli-sequence.ipynb
 examples/mechanisms/Ca.mod
 examples/mechanisms/CaDynamics_DC0.mod
 examples/mechanisms/CaDynamics_E2.mod
@@ -394,11 +399,13 @@ tests/mechanisms/kmb.mod
 tests/mechanisms/na3n.mod
 tests/mechanisms/naxn.mod
 tests/mechanisms/netstim_inhpoisson.mod
+tests/test_analysis/test_inject_sequence.py
 tests/test_cell/__init__.py
 tests/test_cell/test_cell_dict.py
 tests/test_cell/test_core.py
 tests/test_cell/test_injector.py
 tests/test_cell/test_random.py
+tests/test_cell/test_recording.py
 tests/test_cell/test_serialized_sections.py
 tests/test_cell/test_sonata_proxy.py
 tests/test_cell/test_stimuli_generator.py

bluecellulab-2.4.1/examples/1-singlecell/README.md

@@ -0,0 +1,5 @@
+### Provenance for the hoc and morph files
+
+hoc: BlueCelluLab/tests/examples/circuit_sonata_quick_scx/components/hoc/cADpyr_L2TPC.hoc'
+morph: BlueCelluLab/tests/examples/circuit_sonata_quick_scx/components/morphologies/asc/rr110330_C3_idA.asc
+emodel_properties (retrieved from the circuit): EmodelProperties(threshold_current=1.1433533430099487, holding_current=1.4146618843078613, AIS_scaler=1.4561502933502197, soma_scaler=1.0)