bluecellulab 2.2.7__py3-none-any.whl → 2.3.2__py3-none-any.whl

bluecellulab/cell/core.py

@@ -27,12 +27,11 @@ import numpy as np
 import pandas as pd
 
 import bluecellulab
-from bluecellulab import psection
+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.serialized_sections import SerializedSections
 from bluecellulab.cell.template import NeuronTemplate, public_hoc_cell
 from bluecellulab.circuit.config.sections import Conditions
 from bluecellulab.circuit import EmodelProperties, SynapseProperty
@@ -42,7 +41,7 @@ from bluecellulab.exceptions import BluecellulabError
 from bluecellulab.importer import load_hoc_and_mod_files
 from bluecellulab.neuron_interpreter import eval_neuron
 from bluecellulab.rngsettings import RNGSettings
-from bluecellulab.stimuli import SynapseReplay
+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
@@ -99,8 +98,6 @@ class Cell(InjectableMixin, PlottableMixin):
         # diameters of the loaded morph are wrong
         neuron.h.finitialize()
 
-        self.cellname = neuron.h.secname(sec=self.soma).split(".")[0]
-
         if rng_settings is None:
             self.rng_settings = RNGSettings("Random123")  # SONATA value
         else:
@@ -112,25 +109,17 @@ class Cell(InjectableMixin, PlottableMixin):
 
         self.ips: dict[SynapseID, HocObjectType] = {}
         self.syn_mini_netcons: dict[SynapseID, HocObjectType] = {}
-        self.serialized: Optional[SerializedSections] = None
 
         # Be careful when removing this,
         # time recording needs this push
         self.soma.push()
         self.hocname = neuron.h.secname(sec=self.soma).split(".")[0]
-        self.somatic = list(public_hoc_cell(self.cell).somatic)
-        self.basal = list(public_hoc_cell(self.cell).basal)  # dend is same as basal
-        self.apical = list(public_hoc_cell(self.cell).apical)
-        self.axonal = list(public_hoc_cell(self.cell).axonal)
-        self.all = list(public_hoc_cell(self.cell).all)
         self.record_dt = record_dt
         self.add_recordings(['self.soma(0.5)._ref_v', 'neuron.h._ref_t'],
                             dt=self.record_dt)
 
         self.delayed_weights = queue.PriorityQueue()  # type: ignore
-        self.secname_to_isec: dict[str, int] = {}
-        self.secname_to_hsection: dict[str, HocObjectType] = {}
-        self.secname_to_psection: dict[str, psection.PSection] = {}
+        self.psections, self.secname_to_psection = init_psections(public_hoc_cell(self.cell))
 
         self.emodel_properties = emodel_properties
         if template_format == 'v6':
@@ -153,12 +142,29 @@ class Cell(InjectableMixin, PlottableMixin):
         # Used to know when re_init_rng() can be executed
         self.is_made_passive = False
 
-        self.psections: dict[int, psection.PSection] = {}
-
         neuron.h.pop_section()  # Undoing soma push
-        # self.init_psections()
         self.sonata_proxy: Optional[SonataProxy] = None
 
+    @property
+    def somatic(self) -> list[NeuronSection]:
+        return list(public_hoc_cell(self.cell).somatic)
+
+    @property
+    def basal(self) -> list[NeuronSection]:
+        return list(public_hoc_cell(self.cell).basal)
+
+    @property
+    def apical(self) -> list[NeuronSection]:
+        return list(public_hoc_cell(self.cell).apical)
+
+    @property
+    def axonal(self) -> list[NeuronSection]:
+        return list(public_hoc_cell(self.cell).axonal)
+
+    @property
+    def all(self) -> list[NeuronSection]:
+        return list(public_hoc_cell(self.cell).all)
+
     def __repr__(self) -> str:
         base_info = f"Cell Object: {super().__repr__()}"
         hoc_info = f"NEURON ID: {self.template_id}"
@@ -168,47 +174,6 @@ class Cell(InjectableMixin, PlottableMixin):
         """Connect this cell to a circuit via sonata proxy."""
         self.sonata_proxy = sonata_proxy
 
-    def init_psections(self) -> None:
-        """Initialize the psections list.
-
-        This list contains the Python representation of the psections of
-        this morphology.
-        """
-        for hsection in self.all:
-            secname = neuron.h.secname(sec=hsection)
-            self.secname_to_hsection[secname] = hsection
-            self.secname_to_psection[secname] = psection.PSection(hsection)
-
-        # section are not serialized yet, do it now
-        if self.serialized is None:
-            self.serialized = SerializedSections(public_hoc_cell(self.cell))
-
-        for isec in self.serialized.isec2sec:
-            hsection = self.get_hsection(isec)
-            if hsection:
-                secname = neuron.h.secname(sec=hsection)
-                self.psections[isec] = self.secname_to_psection[secname]
-                self.psections[isec].isec = isec
-                self.secname_to_isec[secname] = isec
-
-        # Set the parents and children of all the psections
-        for psec in self.psections.values():
-            hparent = psec.hparent
-            if hparent:
-                parentname = neuron.h.secname(sec=hparent)
-                psec.pparent = self.get_psection(secname=parentname)
-            else:
-                psec.pparent = None
-
-            for hchild in psec.hchildren:
-                childname = neuron.h.secname(sec=hchild)
-                pchild = self.get_psection(secname=childname)
-                psec.add_pchild(pchild)
-
-    def get_section_id(self, secname: str) -> int:
-        """Returns the id of the section with name secname."""
-        return self.secname_to_psection[secname].isec
-
     def re_init_rng(self, use_random123_stochkv: bool = False) -> None:
         """Reinitialize the random number generator for stochastic channels."""
 
@@ -233,44 +198,16 @@ class Cell(InjectableMixin, PlottableMixin):
             else:
                 self.cell.re_init_rng()
 
-    def get_psection(self, section_id=None, secname=None):
-        """Return a python section with the specified section id or name.
-
-        Parameters
-        ----------
-        section_id: int
-                    Return the PSection object based on section id
-        secname: string
-                 Return the PSection object based on section name
-
-        Returns
-        -------
-        psection: PSection
-                  PSection object of the specified section id or name
-        """
-        if section_id is not None:
+    def get_psection(self, section_id: int | str) -> PSection:
+        """Return a python section with the specified section id."""
+        if isinstance(section_id, int):
             return self.psections[section_id]
-        elif secname is not None:
-            return self.secname_to_psection[secname]
+        elif isinstance(section_id, str):
+            return self.secname_to_psection[section_id]
         else:
-            raise Exception(
-                "Cell: get_psection requires or a section_id or a secname")
-
-    def get_hsection(self, section_id: int | float) -> NeuronSection:
-        """Use the serialized object to find a hoc section from a section
-        id."""
-        section_id = int(section_id)
-        # section are not serialized yet, do it now
-        if self.serialized is None:
-            self.serialized = SerializedSections(public_hoc_cell(self.cell))
-
-        try:
-            sec_ref = self.serialized.isec2sec[section_id]
-        except IndexError as e:
-            raise IndexError(
-                f"bluecellulab get_hsection: section-id {section_id} not found in {self.morphology_path}"
-            ) from e
-        return sec_ref.sec
+            raise BluecellulabError(
+                f"Section id must be an int or a str, not {type(section_id)}"
+            )
 
     def make_passive(self) -> None:
         """Make the cell passive by deactivating all the active channels."""
@@ -551,7 +488,8 @@ class Cell(InjectableMixin, PlottableMixin):
 
         base_seed = self.rng_settings.base_seed
         weight = syn_description[SynapseProperty.G_SYNX]
-        post_sec_id = syn_description[SynapseProperty.POST_SECTION_ID]
+        # numpy int to int
+        post_sec_id = int(syn_description[SynapseProperty.POST_SECTION_ID])
 
         location = SynapseFactory.determine_synapse_location(
             syn_description, self
@@ -572,7 +510,7 @@ class Cell(InjectableMixin, PlottableMixin):
             spont_minis_rate = inh_mini_frequency
 
         if spont_minis_rate is not None and spont_minis_rate > 0:
-            sec = self.get_hsection(post_sec_id)
+            sec = self.get_psection(post_sec_id).hsection
             # add the *minis*: spontaneous synaptic events
             self.ips[synapse_id] = neuron.h.\
                 InhPoissonStim(location, sec=sec)

bluecellulab/cell/injector.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Contains injection functionality for the cell."""
-
+from __future__ import annotations
 import math
 import warnings
 import logging
@@ -27,7 +27,7 @@ from bluecellulab.cell.stimuli_generator import (
     get_relative_shotnoise_params,
 )
 from bluecellulab.exceptions import BluecellulabError
-from bluecellulab.stimuli import (
+from bluecellulab.stimulus.circuit_stimulus_definitions import (
     ClampMode,
     Hyperpolarizing,
     Noise,
@@ -36,7 +36,8 @@ from bluecellulab.stimuli import (
     RelativeOrnsteinUhlenbeck,
     RelativeShotNoise,
 )
-from bluecellulab.type_aliases import HocObjectType
+from bluecellulab.stimulus.factory import StimulusFactory
+from bluecellulab.type_aliases import NeuronSection
 
 
 logger = logging.getLogger(__name__)
@@ -69,36 +70,62 @@ class InjectableMixin:
         self.persistent.append(tstim)
         return tstim
 
-    def add_step(self, start_time, stop_time, level, section=None, segx=0.5):
-        """Add a step current injection."""
-        if section is None:
-            section = self.soma
-
-        tstim = neuron.h.TStim(segx, sec=section)
-        duration = stop_time - start_time
-        tstim.pulse(start_time, duration, level)
-        self.persistent.append(tstim)
-        return tstim
+    def add_step(
+        self,
+        start_time: float,
+        stop_time: float,
+        level: float,
+        section: NeuronSection | None = None,
+        segx: float = 0.5,
+        dt: float = 0.025
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """Add a step current injection.
 
-    def add_ramp(self, start_time, stop_time, start_level, stop_level,
-                 section=None, segx=0.5):
-        """Add a ramp current injection."""
-        if section is None:
-            section = self.soma
+        Args:
+            start_time: Start time of the step injection in seconds.
+            stop_time: Stop time of the step injection in seconds.
+            level: Current level to inject in nanoamperes (nA).
+            section: The section to inject current into.
+                Defaults to the soma section.
+            segx: The fractional location within the section to inject.
+                Defaults to 0.5 (center of the section).
+
+        Returns:
+            Tuple of time and current data.
+        """
+        stim = StimulusFactory(dt=dt).step(start_time, stop_time, level)
+        t_content, i_content = stim.time, stim.current
+        self.inject_current_waveform(t_content, i_content, section, segx)
+        return (t_content, i_content)
 
-        tstim = neuron.h.TStim(segx, sec=section)
+    def add_ramp(
+        self,
+        start_time: float,
+        stop_time: float,
+        start_level: float,
+        stop_level: float,
+        section: NeuronSection | None = None,
+        segx: float = 0.5,
+        dt: float = 0.025
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """Add a ramp current injection.
 
-        tstim.ramp(
-            0.0,
-            start_time,
-            start_level,
-            stop_level,
-            stop_time - start_time,
-            0.0,
-            0.0)
+        Args:
+            start_time: Start time of the ramp injection in seconds.
+            stop_time: Stop time of the ramp injection in seconds.
+            start_level: Current level at the start of the ramp in nanoamperes (nA).
+            stop_level: Current level at the end of the ramp in nanoamperes (nA).
+            section: The section to inject current into (optional). Defaults to soma.
+            segx: The fractional location within the section to inject (optional).
+
+        Returns:
+            A tuple of numpy arrays containing time and current data.
+        """
+        stim = StimulusFactory(dt=dt).ramp(start_time, stop_time, start_level, stop_level)
+        t_content, i_content = stim.time, stim.current
+        self.inject_current_waveform(t_content, i_content, section, segx)
 
-        self.persistent.append(tstim)
-        return tstim
+        return t_content, i_content
 
     def add_voltage_clamp(
             self, stop_time, level, rs=None, section=None, segx=0.5,
@@ -395,32 +422,22 @@ class InjectableMixin:
         else:
             return self.inject_current_clamp_signal(section, segx, tvec, svec)
 
-    def inject_current_waveform(self, t_content, i_content, section=None,
-                                segx=0.5):
-        """Inject a custom current to the cell."""
-        start_time = t_content[0]
-        stop_time = t_content[-1]
-        time = neuron.h.Vector()
-        currents = neuron.h.Vector()
-        time = time.from_python(t_content)
-        currents = currents.from_python(i_content)
-
+    def inject_current_waveform(self, t_content, i_content, section=None, segx=0.5):
+        """Inject a custom current waveform into the cell."""
         if section is None:
             section = self.soma
+
+        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.append(pulse)
-        self.persistent.append(time)
-        self.persistent.append(currents)
-        setattr(pulse, 'del', start_time)
-        pulse.dur = stop_time - start_time
-        currents.play(pulse._ref_amp, time)
-        return currents
-
-    @deprecated("Use inject_current_waveform instead.")
-    def injectCurrentWaveform(self, t_content, i_content, section=None,
-                              segx=0.5):
-        """Inject a current in the cell."""
-        return self.inject_current_waveform(t_content, i_content, section, segx)
+        self.persistent.extend([pulse, 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)
+
+        return current_vector
 
     @deprecated("Use add_sin_current instead.")
     def addSineCurrentInject(self, start_time, stop_time, freq,
@@ -435,7 +452,7 @@ class InjectableMixin:
         t_content = np.arange(start_time, stop_time, dt)
         i_content = [amplitude * math.sin(freq * (x - start_time) * (
             2 * math.pi)) + mid_level for x in t_content]
-        self.injectCurrentWaveform(t_content, i_content)
+        self.inject_current_waveform(t_content, i_content)
         return (t_content, i_content)
 
     def add_sin_current(self, amp, start_time, duration, frequency,
@@ -454,9 +471,9 @@ class InjectableMixin:
         tau: float,
         gmax: float,
         e: float,
-        section: HocObjectType,
+        section: NeuronSection,
         segx=0.5,
-    ) -> HocObjectType:
+    ) -> NeuronSection:
         """Add an AlphaSynapse NEURON point process stimulus to the cell."""
         syn = neuron.h.AlphaSynapse(segx, sec=section)
         syn.onset = onset

bluecellulab/cell/plotting.py

@@ -60,7 +60,6 @@ class PlottableMixin:
             scale_bar_size=10.0,
             fig_title=None):
         """Show a dendrogram of the cell."""
-        self.init_psections()
         cell_dendrogram = bluecellulab.Dendrogram(
             self.psections,
             variable=variable,

bluecellulab/cell/serialized_sections.py

@@ -13,11 +13,11 @@
 # limitations under the License.
 """Module that allows morphology sections to be accessed from an array by
 index."""
-
+from __future__ import annotations
 import logging
 import warnings
 import neuron
-from bluecellulab.type_aliases import HocObjectType
+from bluecellulab.type_aliases import HocObjectType, NeuronSection
 
 
 logger = logging.getLogger(__name__)
@@ -27,7 +27,7 @@ warnings.filterwarnings("once", category=UserWarning, module=__name__)
 class SerializedSections:
 
     def __init__(self, cell: HocObjectType) -> None:
-        self.isec2sec = {}
+        self.isec2sec: dict[int, NeuronSection] = {}
         n = cell.nSecAll
 
         for index, sec in enumerate(cell.all, start=1):

bluecellulab/circuit/config/bluepy_simulation_config.py

@@ -25,7 +25,7 @@ if BLUEPY_AVAILABLE:
     from bluepy.utils import open_utf8
 
 from bluecellulab.circuit.config.sections import Conditions, ConnectionOverrides
-from bluecellulab.stimuli import Stimulus
+from bluecellulab.stimulus.circuit_stimulus_definitions import Stimulus
 
 
 class BluepySimulationConfig:

bluecellulab/circuit/config/definition.py

@@ -18,7 +18,7 @@ from typing import Optional, Protocol
 
 
 from bluecellulab.circuit.config.sections import Conditions, ConnectionOverrides
-from bluecellulab.stimuli import Stimulus
+from bluecellulab.stimulus.circuit_stimulus_definitions import Stimulus
 
 
 class SimulationConfig(Protocol):

bluecellulab/circuit/config/sonata_simulation_config.py

@@ -17,7 +17,7 @@ from pathlib import Path
 from typing import Optional
 
 from bluecellulab.circuit.config.sections import Conditions, ConnectionOverrides
-from bluecellulab.stimuli import Stimulus
+from bluecellulab.stimulus.circuit_stimulus_definitions import Stimulus
 
 from bluepysnap import Simulation as SnapSimulation
 

bluecellulab/dendrogram.py

@@ -12,8 +12,54 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Class that represents a dendrogram window."""
-
+from __future__ import annotations
 import numpy as np
+import pylab
+
+from bluecellulab.psection import PSection
+from bluecellulab.psegment import PSegment
+
+
+def setup_draw(psegments: list[PSegment], maxsegdiam: float, figure, x, y, variable=None, varbounds=None) -> None:
+    """Setup draw of psection."""
+    y_accum = 0.0
+    for psegment in psegments:
+        psegment.setupDraw(figure,
+                           x + (maxsegdiam - psegment.diam) / 2,
+                           y + y_accum,
+                           variable=variable,
+                           varbounds=varbounds)
+        y_accum += psegment.L
+
+
+def draw_tree(psection: PSection, figure, x, y, variable=None, varbounds=None) -> None:
+    """Draw a dendritic tree."""
+    # Draw myself
+    setup_draw(
+        psection.psegments, psection.maxsegdiam, figure, x, y, variable=variable, varbounds=varbounds
+    )
+
+    # Draw children
+
+    # First child is a same x coordinate
+    new_x = x  # + self.L + self.xSpacing
+
+    # Children drawn L + ySpacing heigher
+    new_y = y + psection.L + psection.ySpacing
+
+    for child in psection.pchildren:
+        draw_tree(child, figure, new_x, new_y, variable=variable, varbounds=varbounds)
+        pylab.plot(
+            [x + psection.diam / 2, new_x + child.diam / 2],
+            [y + psection.L, new_y], 'k')
+        # Prepare new_x for next child
+        new_x = new_x + child.tree_width()
+
+
+def redraw_psection(psection: PSection) -> None:
+    """Redraw psection."""
+    for psegment in psection.psegments:
+        psegment.redraw()
 
 
 class Dendrogram:
@@ -21,7 +67,7 @@ class Dendrogram:
 
     def __init__(
             self,
-            psections,
+            psections: list[PSection],
             variable=None,
             active=False,
             save_fig_path=None,
@@ -30,7 +76,6 @@ class Dendrogram:
             scale_bar_size=10.0,
             fig_title=None,
             fig_show=True):
-        import pylab
 
         if interactive:
             pylab.ion()
@@ -48,15 +93,14 @@ class Dendrogram:
         self.psections = psections
         # neuron.h.finitialize()
 
-        # self.hroot = neuron.h.SectionRef(sec=self.sections[0]).root
-        self.proot = psections[0]
-        # self.psections = [self.proot] + self.proot.getAllPDescendants()
+        self.proot: PSection = psections[0]
+        self.psections = [self.proot] + self.proot.all_descendants()
 
         xSpacing = self.proot.xSpacing
         ySpacing = self.proot.ySpacing
 
-        max_y = self.proot.treeHeight() + self.proot.ySpacing + title_space
-        max_x = self.proot.treeWidth() + self.proot.xSpacing + scale_bar_size
+        max_y = self.proot.tree_height() + self.proot.ySpacing + title_space
+        max_x = self.proot.tree_width() + self.proot.xSpacing + scale_bar_size
         pylab.xlim([0, max_x])
         pylab.ylim([0, max_y])
         pylab.gca().set_xticks([])
@@ -79,9 +123,9 @@ class Dendrogram:
             cbar.ax.set_yticklabels(["%.2e" % (
                 varbounds[0]), "%.2e" % (varbounds[1])])
 
-        self.proot.drawTree(self.dend_figure, self.proot.xSpacing,
-                            self.proot.ySpacing, variable=variable,
-                            varbounds=varbounds)
+        draw_tree(self.proot, self.dend_figure, self.proot.xSpacing,
+                  self.proot.ySpacing, variable=variable,
+                  varbounds=varbounds)
 
         if scale_bar:
             pylab.plot(
@@ -119,8 +163,10 @@ class Dendrogram:
 
         self.dend_figure.canvas.draw()
 
-        for secid in self.psections:
-            psections[secid].redraw()
+        for section in self.psections:
+            section_id = section.isec
+            if section_id is not None:
+                redraw_psection(psections[section_id])
 
         self.canvas = self.dend_figure.gca().figure.canvas
         self.ax = self.dend_figure.gca()
@@ -138,15 +184,13 @@ class Dendrogram:
         if not interactive and fig_show:
             pylab.show()
 
-    def redraw(self):
+    def redraw(self) -> None:
         """Redraw the dendrogram."""
         if self.active:
             if not self.drawCount:
                 for psection in self.psections:
-                    psection.redraw()
+                    redraw_psection(psection)
                 self.canvas.blit(self.ax.bbox)
                 self.drawCount = 1
             else:
                 self.drawCount = self.drawCount - 1
-
-        return True

bluecellulab/psection.py

@@ -12,23 +12,67 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Represents a python version of NEURON Section (for drawing)."""
-
+from __future__ import annotations
 import neuron
 
 import bluecellulab
+from bluecellulab.cell.serialized_sections import SerializedSections
+from bluecellulab.psegment import PSegment
+from bluecellulab.type_aliases import HocObjectType, NeuronSection
+
+
+def init_psections(
+    hoc_cell: HocObjectType,
+) -> tuple[dict[int, PSection], dict[str, PSection]]:
+    """Initialize the psections list.
+
+    This list contains the Python representation of the psections of
+    this morphology.
+    """
+    psections: dict[int, PSection] = {}
+    secname_to_psection: dict[str, PSection] = {}
+    for sec in hoc_cell.all:
+        secname = neuron.h.secname(sec=sec)
+        secname_to_psection[secname] = PSection(sec)
+
+    serial_sections = SerializedSections(hoc_cell)
+    for isec, val in serial_sections.isec2sec.items():
+        hsection: NeuronSection = val.sec
+        if hsection:
+            secname = neuron.h.secname(sec=hsection)
+            psections[isec] = secname_to_psection[secname]
+            psections[isec].isec = isec
+
+    # Set the parents and children of all the psections
+    for psec in psections.values():
+        hparent = psec.hparent
+        if hparent:
+            parentname = hparent.name()
+            psec.pparent = secname_to_psection[parentname]
+        else:
+            psec.pparent = None
+
+        for hchild in psec.hchildren:
+            childname = hchild.name()
+            if "myelin" in childname:
+                continue
+            pchild = secname_to_psection[childname]
+            psec.add_pchild(pchild)
+
+    return psections, secname_to_psection
 
 
 class PSection:
     """Class that represents a cell section."""
 
-    def __init__(self, hsection, isec=None):
-        self.L = hsection.L
-        self.diam = hsection.diam
+    def __init__(self, hsection: NeuronSection, isec: int | None = None):
+        self.L: float = hsection.L
+        self.diam: float = hsection.diam
         self.hsection = hsection
-        self.name = neuron.h.secname(sec=hsection)
-        self.href = neuron.h.SectionRef(sec=self.hsection)
-        self.pparent = None
-        self.pchildren = []
+        self.name: str = neuron.h.secname(sec=hsection)
+        self.href: NeuronSection = neuron.h.SectionRef(sec=self.hsection)
+        self.pparent: PSection | None = None
+        self.pchildren: list[PSection] = []
         self.isec = isec
 
         if 'apic' in self.name:
@@ -46,24 +90,24 @@ class PSection:
                 "PSection: Section of unknown type: %s" %
                 self.name)
 
-        self.psegments = []
-        self.maxsegdiam = 0
+        self.psegments: list[PSegment] = []
+        self.maxsegdiam = 0.0
         for hsegment in hsection:
             # psegment = bluecellulab.PSegment(hsection(hsegment.x), self)
             psegment = bluecellulab.PSegment(hsegment, self)
             self.psegments.append(psegment)
             self.maxsegdiam = max(self.maxsegdiam, psegment.diam)
 
-        self.xSpacing = 1
-        self.ySpacing = 5
+        self.xSpacing = 1.0
+        self.ySpacing = 5.0
 
     @property
-    def isLeaf(self):
+    def is_leaf(self) -> bool:
         """Return true if section is a leaf in the morphological structure."""
         return not self.hchildren
 
     @property
-    def hparent(self):
+    def hparent(self) -> NeuronSection | None:
         """Return the hoc section of the parent."""
         if self.href.has_parent():
             return self.href.parent
@@ -71,37 +115,22 @@ class PSection:
             return None
 
     @property
-    def hchildren(self):
+    def hchildren(self) -> list[NeuronSection]:
         """Return a list with the hoc sections of the children."""
         return [self.href.child[index] for index in
                 range(0, int(self.href.nchild()))]
 
-    def add_pchild(self, pchild):
+    def add_pchild(self, pchild: PSection) -> None:
         """Add a python represent of a child section."""
         self.pchildren.append(pchild)
-
-    def setupDraw(self, figure, x, y, variable=None, varbounds=None):
-        """Setup draw of psection."""
-        y_accum = 0
-        for psegment in self.psegments:
-            psegment.setupDraw(figure,
-                               x + (self.maxsegdiam - psegment.diam) / 2,
-                               y + y_accum,
-                               variable=variable,
-                               varbounds=varbounds)
-            y_accum += psegment.L
-
-    def redraw(self):
-        """Redraw psection."""
-        for psegment in self.psegments:
-            psegment.redraw()
+        pchild.pparent = self
 
     def getSectionVarBounds(self, variable):
         """Get bounds a variable in a section."""
         varmin = None
         varmax = None
         for psegment in self.psegments:
-            value = psegment.getVariableValue(variable)
+            value = psegment.get_variable_value(variable)
             if value:
                 varmin = min(value, varmin) if varmin else value
                 varmax = max(value, varmax) if varmax else value
@@ -122,51 +151,23 @@ class PSection:
 
         return varbounds
 
-    def getAllPDescendants(self):
+    def all_descendants(self) -> list[PSection]:
         """Return all the psection that are descendants of this psection."""
         pdescendants = list(self.pchildren)
         for child in self.pchildren:
-            pdescendants += child.getAllPDescendants()
+            pdescendants += child.all_descendants()
         return pdescendants
 
-    def drawTree(self, figure, x, y, variable=None, varbounds=None):
-        """Draw a dendritic tree."""
-        import pylab
-
-        # Draw myself
-        self.setupDraw(figure, x, y, variable=variable, varbounds=varbounds)
-
-        # Draw children
-
-        # First child is a same x coordinate
-        new_x = x  # + self.L + self.xSpacing
-
-        # Children drawn L + ySpacing heigher
-        new_y = y + self.L + self.ySpacing
-
-        for child in self.pchildren:
-            child.drawTree(
-                figure, new_x, new_y, variable=variable, varbounds=varbounds)
-            pylab.plot(
-                [x + self.diam / 2, new_x + child.diam / 2],
-                [y + self.L, new_y], 'k')
-            # Prepare new_x for next child
-            new_x = new_x + child.treeWidth()
-
-    def treeWidth(self):
+    def tree_width(self) -> float:
         """Width of a dendritic tree."""
-        if self.isLeaf:
-            treeWidth = self.maxsegdiam + self.xSpacing
+        if self.is_leaf:
+            width = self.maxsegdiam + self.xSpacing
         else:
-            treeWidth = sum(child.treeWidth() for child in self.pchildren)
-        return max(self.diam + self.xSpacing, treeWidth)
+            width = sum(child.tree_width() for child in self.pchildren)
+        return max(self.diam + self.xSpacing, width)
 
-    def treeHeight(self):
+    def tree_height(self) -> float:
         """Height of dendritic tree."""
         return self.L + self.ySpacing + \
-            (max([child.treeHeight() for child in self.pchildren])
+            (max([child.tree_height() for child in self.pchildren])
              if self.pchildren else 0)
-
-    def getHChildren(self):
-        """All hoc children of a section."""
-        return self.hchildren

bluecellulab/psegment.py

@@ -61,7 +61,7 @@ class PSegment:
     def redraw(self):
         """Redraw a segment."""
         if self.plotvariable:
-            plotvariable_value = self.getVariableValue(self.plotvariable)
+            plotvariable_value = self.get_variable_value(self.plotvariable)
             if plotvariable_value is not None:
                 self.patch.set_facecolor(self.color_map(
                     (plotvariable_value - self.varbounds[0]) /
@@ -71,7 +71,7 @@ class PSegment:
                 self.patch.set_hatch("/")
             self.ax.draw_artist(self.patch)
 
-    def getVariableValue(self, variable):
+    def get_variable_value(self, variable):
         """Get a variable value in a segment."""
         if variable == "v" or neuron.h.execute1(
             "{%s.%s(%f)}"

bluecellulab/ssim.py

@@ -40,8 +40,8 @@ from bluecellulab.circuit.format import determine_circuit_format, CircuitFormat
 from bluecellulab.circuit.node_id import create_cell_id, create_cell_ids
 from bluecellulab.circuit.simulation_access import BluepySimulationAccess, SimulationAccess, SonataSimulationAccess, _sample_array
 from bluecellulab.importer import load_hoc_and_mod_files
-from bluecellulab.stimuli import Noise, OrnsteinUhlenbeck, RelativeOrnsteinUhlenbeck, RelativeShotNoise, ShotNoise
-import bluecellulab.stimuli as stimuli
+from bluecellulab.stimulus.circuit_stimulus_definitions import Noise, OrnsteinUhlenbeck, RelativeOrnsteinUhlenbeck, RelativeShotNoise, ShotNoise
+import bluecellulab.stimulus.circuit_stimulus_definitions as circuit_stimulus_definitions
 from bluecellulab.exceptions import BluecellulabError
 from bluecellulab.simulation import (
     set_global_condition_parameters,
@@ -298,40 +298,40 @@ class SSim:
             for cell_id in self.cells:
                 if cell_id not in gids_of_target:
                     continue
-                if isinstance(stimulus, stimuli.Noise):
+                if isinstance(stimulus, circuit_stimulus_definitions.Noise):
                     if add_noise_stimuli:
                         self.cells[cell_id].add_replay_noise(
                             stimulus, noisestim_count=noisestim_count)
-                elif isinstance(stimulus, stimuli.Hyperpolarizing):
+                elif isinstance(stimulus, circuit_stimulus_definitions.Hyperpolarizing):
                     if add_hyperpolarizing_stimuli:
                         self.cells[cell_id].add_replay_hypamp(stimulus)
-                elif isinstance(stimulus, stimuli.Pulse):
+                elif isinstance(stimulus, circuit_stimulus_definitions.Pulse):
                     if add_pulse_stimuli:
                         self.cells[cell_id].add_pulse(stimulus)
-                elif isinstance(stimulus, stimuli.RelativeLinear):
+                elif isinstance(stimulus, circuit_stimulus_definitions.RelativeLinear):
                     if add_relativelinear_stimuli:
                         self.cells[cell_id].add_replay_relativelinear(stimulus)
-                elif isinstance(stimulus, stimuli.ShotNoise):
+                elif isinstance(stimulus, circuit_stimulus_definitions.ShotNoise):
                     if add_shotnoise_stimuli:
                         self.cells[cell_id].add_replay_shotnoise(
                             self.cells[cell_id].soma, 0.5, stimulus,
                             shotnoise_stim_count=shotnoise_stim_count)
-                elif isinstance(stimulus, stimuli.RelativeShotNoise):
+                elif isinstance(stimulus, circuit_stimulus_definitions.RelativeShotNoise):
                     if add_shotnoise_stimuli:
                         self.cells[cell_id].add_replay_relative_shotnoise(
                             self.cells[cell_id].soma, 0.5, stimulus,
                             shotnoise_stim_count=shotnoise_stim_count)
-                elif isinstance(stimulus, stimuli.OrnsteinUhlenbeck):
+                elif isinstance(stimulus, circuit_stimulus_definitions.OrnsteinUhlenbeck):
                     if add_ornstein_uhlenbeck_stimuli:
                         self.cells[cell_id].add_ornstein_uhlenbeck(
                             self.cells[cell_id].soma, 0.5, stimulus,
                             stim_count=ornstein_uhlenbeck_stim_count)
-                elif isinstance(stimulus, stimuli.RelativeOrnsteinUhlenbeck):
+                elif isinstance(stimulus, circuit_stimulus_definitions.RelativeOrnsteinUhlenbeck):
                     if add_ornstein_uhlenbeck_stimuli:
                         self.cells[cell_id].add_relative_ornstein_uhlenbeck(
                             self.cells[cell_id].soma, 0.5, stimulus,
                             stim_count=ornstein_uhlenbeck_stim_count)
-                elif isinstance(stimulus, stimuli.SynapseReplay):  # sonata only
+                elif isinstance(stimulus, circuit_stimulus_definitions.SynapseReplay):  # sonata only
                     if self.circuit_access.target_contains_cell(
                         stimulus.target, cell_id
                     ):

bluecellulab/stimulus/__init__.py

@@ -0,0 +1 @@
+from .factory import StimulusFactory

bluecellulab/{stimuli.py → stimulus/circuit_stimulus_definitions.py}

@@ -11,7 +11,11 @@
 # 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.
+"""Defines the expected data structures associated with the stimulus defined in
+simulation configs.
 
+Run-time validates the data via Pydantic.
+"""
 from __future__ import annotations
 
 from enum import Enum

bluecellulab/stimulus/factory.py

@@ -0,0 +1,254 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+class Stimulus(ABC):
+    def __init__(self, dt: float) -> None:
+        self.dt = dt
+
+    @property
+    @abstractmethod
+    def time(self) -> np.ndarray:
+        """Time values of the stimulus."""
+        ...
+
+    @property
+    @abstractmethod
+    def current(self) -> np.ndarray:
+        """Current values of the stimulus."""
+        ...
+
+    def __len__(self) -> int:
+        return len(self.time)
+
+    @property
+    def stimulus_time(self) -> float:
+        return len(self) * self.dt
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(dt={self.dt})"
+
+    def plot(self, ax=None, **kwargs):
+        if ax is None:
+            ax = plt.gca()
+        ax.plot(self.time, self.current, **kwargs)
+        ax.set_xlabel("Time (ms)")
+        ax.set_ylabel("Current (nA)")
+        ax.set_title(self.__class__.__name__)
+        return ax
+
+    def plot_during_simulation(self, duration: float, ax=None, **kwargs):
+        if ax is None:
+            ax = plt.gca()
+        # Create an array for the entire duration
+        full_time = np.arange(0, duration, self.dt)
+        full_current = np.zeros_like(full_time)
+
+        # Replace the corresponding values with self.time and self.current
+        indices = (self.time / self.dt).astype(int)
+        full_current[indices] = self.current
+
+        ax.plot(full_time, full_current, **kwargs)
+        ax.set_xlabel("Time (ms)")
+        ax.set_ylabel("Current (nA)")
+        ax.set_title(self.__class__.__name__)
+        ax.set_xlim(0, duration)
+        return ax
+
+    def __add__(self, other: Stimulus) -> CombinedStimulus:
+        """Override + operator to concatenate Stimulus objects."""
+        if self.dt != other.dt:
+            raise ValueError("Stimulus objects must have the same dt to be concatenated")
+        # shift other time
+        other_time = other.time + self.time[-1] + self.dt
+        combined_time = np.concatenate([self.time, other_time])
+        # Concatenate the current arrays
+        combined_current = np.concatenate([self.current, other.current])
+        return CombinedStimulus(self.dt, combined_time, combined_current)
+
+
+class CombinedStimulus(Stimulus):
+    """Represents the Stimulus created by combining multiple stimuli."""
+    def __init__(self, dt: float, time: np.ndarray, current: np.ndarray) -> None:
+        super().__init__(dt)
+        self._time = time
+        self._current = current
+
+    @property
+    def time(self) -> np.ndarray:
+        return self._time
+
+    @property
+    def current(self) -> np.ndarray:
+        return self._current
+
+
+class EmptyStimulus(Stimulus):
+    """Represents empty stimulus (all zeros) that has no impact on the cell.
+
+    This is required by some Stimuli that expect the cell to rest.
+    """
+    def __init__(self, dt: float, duration: float) -> None:
+        super().__init__(dt)
+        self.duration = duration
+
+    @property
+    def time(self) -> np.ndarray:
+        return np.arange(0.0, self.duration, self.dt)
+
+    @property
+    def current(self) -> np.ndarray:
+        return np.zeros_like(self.time)
+
+
+class Step(Stimulus):
+    def __init__(self, dt: float, start: float, end: float, amplitude: float) -> None:
+        super().__init__(dt)
+        self.start = start
+        self.end = end
+        self.amplitude = amplitude
+
+    @classmethod
+    def threshold_based(
+        cls,
+        dt: float,
+        threshold_current: float,
+        threshold_percentage: float,
+        start: float,
+        end: float,
+        post_wait: float,
+    ) -> CombinedStimulus:
+        amplitude = threshold_current * threshold_percentage / 100
+        res = cls(dt, start, end, amplitude) + EmptyStimulus(dt, duration=post_wait)
+        return res
+
+    @property
+    def time(self) -> np.ndarray:
+        return np.arange(self.start, self.end, self.dt)
+
+    @property
+    def current(self) -> np.ndarray:
+        return np.full_like(self.time, self.amplitude)
+
+
+class Ramp(Stimulus):
+    def __init__(
+        self,
+        dt: float,
+        start: float,
+        end: float,
+        amplitude_start: float,
+        amplitude_end: float,
+    ) -> None:
+        super().__init__(dt)
+        self.start = start
+        self.end = end
+        self.amplitude_start = amplitude_start
+        self.amplitude_end = amplitude_end
+
+    @property
+    def time(self) -> np.ndarray:
+        return np.arange(self.start, self.end, self.dt)
+
+    @property
+    def current(self) -> np.ndarray:
+        return np.linspace(self.amplitude_start, self.amplitude_end, len(self.time))
+
+
+class StimulusFactory:
+    def __init__(self, dt: float):
+        self.dt = dt
+
+    def step(self, start: float, end: float, amplitude: float) -> Stimulus:
+        return Step(self.dt, start, end, amplitude)
+
+    def ramp(
+        self, start: float, end: float, amplitude_start: float, amplitude_end: float
+    ) -> Stimulus:
+        return Ramp(self.dt, start, end, amplitude_start, amplitude_end)
+
+    def ap_waveform(
+        self,
+        threshold_current: float,
+        threshold_percentage: float = 220.0,
+        start: float = 250.0,
+        end: float = 300.0,
+        post_wait: float = 250.0,
+    ) -> Stimulus:
+        """Returns the APWaveform Stimulus object, a type of Step stimulus.
+
+        Args:
+            threshold_current: The threshold current of the Cell.
+            threshold_percentage: Percentage of desired threshold_current amplification.
+            start: The start time of the step.
+            end: The end time of the step.
+            post_wait: The time to wait after the end of the step.
+        """
+        return Step.threshold_based(
+            self.dt, threshold_current, threshold_percentage, start, end, post_wait
+        )
+
+    def idrest(
+        self,
+        threshold_current: float,
+        threshold_percentage: float = 200.0,
+        start: float = 250.0,
+        end: float = 1600.0,
+        post_wait: float = 250.0,
+    ) -> Stimulus:
+        """Returns the IDRest Stimulus object, a type of Step stimulus.
+
+        Args:
+            threshold_current: The threshold current of the Cell.
+            threshold_percentage: Percentage of desired threshold_current amplification.
+            start: The start time of the step.
+            end: The end time of the step.
+            post_wait: The time to wait after the end of the step.
+        """
+        return Step.threshold_based(
+            self.dt, threshold_current, threshold_percentage, start, end, post_wait
+        )
+
+    def iv(
+        self,
+        threshold_current: float,
+        threshold_percentage: float = -40.0,
+        start: float = 250.0,
+        end: float = 3250.0,
+        post_wait: float = 250.0,
+    ) -> Stimulus:
+        """Returns the IV Stimulus object, a type of Step stimulus.
+
+        Args:
+            threshold_current: The threshold current of the Cell.
+            threshold_percentage: Percentage of desired threshold_current amplification.
+            start: The start time of the step.
+            end: The end time of the step.
+            post_wait: The time to wait after the end of the step.
+        """
+        return Step.threshold_based(
+            self.dt, threshold_current, threshold_percentage, start, end, post_wait
+        )
+
+    def fire_pattern(
+        self,
+        threshold_current: float,
+        threshold_percentage: float = 200.0,
+        start: float = 250.0,
+        end: float = 3850.0,
+        post_wait: float = 250.0,
+    ) -> Stimulus:
+        """Returns the FirePattern Stimulus object, a type of Step stimulus.
+
+        Args:
+            threshold_current: The threshold current of the Cell.
+            threshold_percentage: Percentage of desired threshold_current amplification.
+            start: The start time of the step.
+            end: The end time of the step.
+            post_wait: The time to wait after the end of the step.
+        """
+        return Step.threshold_based(
+            self.dt, threshold_current, threshold_percentage, start, end, post_wait
+        )

bluecellulab/synapse/synapse_factory.py

@@ -110,8 +110,8 @@ class SynapseFactory:
     @classmethod
     def determine_synapse_location(cls, syn_description: pd.Series, cell: bluecellulab.Cell) -> SynapseHocArgs:
         """Returns the location of the synapse."""
-        isec = syn_description[SynapseProperty.POST_SECTION_ID]
-        section = cell.get_hsection(isec)
+        isec = int(syn_description[SynapseProperty.POST_SECTION_ID])  # numpy int to int
+        section: NeuronSection = cell.get_psection(section_id=isec).hsection
 
         # old circuits don't have it, it needs to be computed via synlocation_to_segx
         if ("afferent_section_pos" in syn_description and

{bluecellulab-2.2.7.dist-info → bluecellulab-2.3.2.dist-info}/METADATA

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

{bluecellulab-2.2.7.dist-info → bluecellulab-2.3.2.dist-info}/RECORD

@@ -1,27 +1,26 @@
 bluecellulab/__init__.py,sha256=tbFwA146uSwNPO1HeVhqHNfxUBPM0VsuNk3NeMCq-Wc,620
 bluecellulab/connection.py,sha256=volV2YKtmqAF7MOEJar5ldF1ARAo7k2vF9MB1NXybUY,4640
-bluecellulab/dendrogram.py,sha256=5L-kPQEBuUl26pywK1EAwJWXj7k2BX6Re0QGAfguk7g,4890
+bluecellulab/dendrogram.py,sha256=w0vvv0Q169DolTX1j9dAZIvHIl4H258gAjQ1xQaNiGk,6427
 bluecellulab/exceptions.py,sha256=KIxF7s_7gPVJ07TiQ-Z1D8de7ylV74gNMhzl0339CVM,2379
 bluecellulab/graph.py,sha256=ODiQy4xjRVxtNITXeXpYnqHas0wR7gZ_aXuDAF7jMq4,3419
 bluecellulab/importer.py,sha256=Sf8_aWqBCp98WfNkLMhNSp4UdurEneFF5leNYRlXjAw,2852
 bluecellulab/neuron_interpreter.py,sha256=hXig_u3T6JmEHbkV8ZblEZtX0kY80ate4VpRtANNFrM,2185
 bluecellulab/plotwindow.py,sha256=UVHzml-BB83m5Qr-YGkjR9kB-vSW8mM0Owh2j95yIaU,2721
-bluecellulab/psection.py,sha256=J93VuSXXjz2oB-Xp6DsC9nSgf5qhW6wPAFjJszBTfGY,6013
-bluecellulab/psegment.py,sha256=9ApDIrryl0IN5hluPe4tQfIWYLttlWjhZNWsaViVfwg,3121
+bluecellulab/psection.py,sha256=EgAS8IS9DcYv2xOkNISgfg_CfRc0nDfRFjvgQhyi9eY,6328
+bluecellulab/psegment.py,sha256=rBryDYHC_uDK9itfXXrFZ0DL9F6WgRICL0j5EHN56QM,3125
 bluecellulab/rngsettings.py,sha256=SLvkgM8K26Z-zTTN__CnFl_KjIJNuF4n_jzviyei5P4,3986
-bluecellulab/ssim.py,sha256=y09WEP5efGll7ddHMJi3qAXr5XJp4O-0cWbpIEbhF9E,33282
-bluecellulab/stimuli.py,sha256=u3AG3u0yYIvZzvFAwl1-8UPvEbq50mERVLVajX8JXdo,15540
+bluecellulab/ssim.py,sha256=_MyUObeKIHhuT4cbB1uSD7izpZZHNRACiPlO9R1TNa8,33552
 bluecellulab/tools.py,sha256=s4NTE0DzK8z8oAy1BF1C2f19nBx-qBPuArz7e7hUTnw,24231
 bluecellulab/type_aliases.py,sha256=EMrunY-pIgZrsmetpAM8lA7tr0TFEzFoU5SX9sBuiOk,312
 bluecellulab/utils.py,sha256=GKZkRYI2LY08tsIkG95MGn7EfmV4pBrIAqfRQCW14fs,300
 bluecellulab/cell/__init__.py,sha256=Sbc0QOsJ8E7tSwf3q7fsXuE_SevBN6ZmoCVyyU5zfII,208
 bluecellulab/cell/cell_dict.py,sha256=PVmZsjhZ9jp3HC-8QmdFqp-crAcVMSVeLWujcOPLlpo,1346
-bluecellulab/cell/core.py,sha256=5Oi8DP96RrFv8jI1XZKi2zpwq5_ZAJtWMDfTWxtidYk,34145
-bluecellulab/cell/injector.py,sha256=zh4Pa-q0dmiB0zzb7-jZgGHEEVgk8_bC7tKKnYtq4v4,16843
-bluecellulab/cell/plotting.py,sha256=V63L_qEhlv8Zo9HdX1X27kIF0Lws9XQ4RLc-shV_xGc,4031
+bluecellulab/cell/core.py,sha256=UtPjq_SYX8wOehQe7GqkbPxDWG1vIIJQ5-e3T_g29YU,31480
+bluecellulab/cell/injector.py,sha256=4h11fObfbKhuvexE_AawCWiAalZIUjDsbVjqOeJ34Tw,17842
+bluecellulab/cell/plotting.py,sha256=_hZs5oYG4vmJBVf05cJ2O_cVazi5Eap8OkL9BtIwjW8,4001
 bluecellulab/cell/random.py,sha256=FDby9BN4eJT27COwHP59bhDE2v-c6rdOKNFj3cYZTVY,1773
 bluecellulab/cell/section_distance.py,sha256=J8-oqgCHzRaJkpfjPUR6NFtXDhwbrXad9nDaTCKNkTU,3908
-bluecellulab/cell/serialized_sections.py,sha256=mbx0c8yzPMLTtJaxAxkki2BdUEOlozKdOmAS3gfPYG4,1539
+bluecellulab/cell/serialized_sections.py,sha256=UQUecO07ChRZ7xHuDp-QAQRUpUiIwROzHxjZliP9gfQ,1614
 bluecellulab/cell/sonata_proxy.py,sha256=dLT9mLlGVpXxj2O2lXN0g7Sq4BwroPLVdPikR2yNMv4,1529
 bluecellulab/cell/stimuli_generator.py,sha256=cJwjNwsQeEBHLjuJIFv6VBSqd9IpmbR7CuSMyotCiWc,6320
 bluecellulab/cell/template.py,sha256=EGZDS7Lb7kScwh0LqKl7BcvA6r5UdNx1_HiYo7ALbPs,8015
@@ -40,10 +39,10 @@ bluecellulab/circuit/circuit_access/bluepy_circuit_access.py,sha256=j-DYHMBTbq1T
 bluecellulab/circuit/circuit_access/definition.py,sha256=SnKBFEgdXFG-QexYRrGSzVAd7bSj7NwN0IuTsjDOrDY,4435
 bluecellulab/circuit/circuit_access/sonata_circuit_access.py,sha256=P1ElK_VA10_JyyKbAnqzuAlduEYE2c_NSec2TZuix1U,10345
 bluecellulab/circuit/config/__init__.py,sha256=aaoJXRKBJzpxxREo9NxKc-_CCPmVeuR1mcViRXcLrC4,215
-bluecellulab/circuit/config/bluepy_simulation_config.py,sha256=YWXlmqTf0tgLgAc6z50xIFtIzYXIgPtQ8BH5Sd1KskQ,6944
-bluecellulab/circuit/config/definition.py,sha256=BvDUnsRQaW-6bF9WVlUrW_gRbmVZYE28LGEbcKXgbqo,2744
+bluecellulab/circuit/config/bluepy_simulation_config.py,sha256=tUyHvzlxFWRxh8rBNvU0FdUqGqJR2G8OXifATQ9W7yw,6974
+bluecellulab/circuit/config/definition.py,sha256=o0751Dd83f8TWGw95EAQ8coJrYGasdshrIrXViF5lzg,2774
 bluecellulab/circuit/config/sections.py,sha256=O1198JvusdOQBWgUeOZ5OhOupbHvvt3NtP9JfBWNbn0,7151
-bluecellulab/circuit/config/sonata_simulation_config.py,sha256=2yPRH-XuBwsaZZfg1fHMl9SgTG-GSYGN2KkJG06a1Ho,4799
+bluecellulab/circuit/config/sonata_simulation_config.py,sha256=P0IKazCuNAG97xq2xLwHLbmr_lrNAqPsa6rXi-uDqb0,4829
 bluecellulab/hoc/Cell.hoc,sha256=z77qRQG_-afj-RLX0xN6V-K6Duq3bR7vmlDrGWPdh4E,16435
 bluecellulab/hoc/RNGSettings.hoc,sha256=wOtPxVMkCBTHsFLs5jPMKyverm1llXqaX8VKsAX43r8,1413
 bluecellulab/hoc/TDistFunc.hoc,sha256=WKX-anvL83xGuGPH9g1oIORB17UM4Pi3-iIXzKO-pUQ,2663
@@ -52,12 +51,15 @@ bluecellulab/hoc/fileUtils.hoc,sha256=LSM7BgyjYVqo2DGSOKvg4W8IIusbsL45JVYK0vgwit
 bluecellulab/simulation/__init__.py,sha256=G1md-6mqaYQkfZT8pmzqRi3WW1fMQCgkeaela2kX3OM,258
 bluecellulab/simulation/neuron_globals.py,sha256=PuAxrXbr734RP-5q6YkHpnOgzTVyo_8SYZux9HABlaI,3348
 bluecellulab/simulation/simulation.py,sha256=tM5Psl-w25CHA4hp2fqs3GcZ2HSjIbu_6iyOcs-1jd8,6439
+bluecellulab/stimulus/__init__.py,sha256=DgIgVaSyR-URf3JZzvO6j-tjCerzvktuK-ep8pjMRPQ,37
+bluecellulab/stimulus/circuit_stimulus_definitions.py,sha256=uij_s44uNdmMwMLGmTHSRgmp9K9B_vvHHshX6YPJNJU,15686
+bluecellulab/stimulus/factory.py,sha256=AOby3Sp2g8BJsRccz3afazfCyysyWIgLtcliWlyeiu0,8097
 bluecellulab/synapse/__init__.py,sha256=RW8XoAMXOvK7OG1nHl_q8jSEKLj9ZN4oWf2nY9HAwuk,192
-bluecellulab/synapse/synapse_factory.py,sha256=qVx8LKVIqdwSXL7_5tuSx9vXy0_pi3RYjGHfpTUGYNA,6802
+bluecellulab/synapse/synapse_factory.py,sha256=ZBRpjvIRyHc4hBfBvtLukLf7E2PjHhzwqGt9O4MBOTk,6862
 bluecellulab/synapse/synapse_types.py,sha256=wWVBfvPYF6g3dSoaXsjJ6QI929yWYrTh_OmauS5Y-Uk,17027
-bluecellulab-2.2.7.dist-info/AUTHORS.txt,sha256=EDs3H-2HXBojbma10psixk3C2rFiOCTIREi2ZAbXYNQ,179
-bluecellulab-2.2.7.dist-info/LICENSE,sha256=xOouu1gC1GGklDxkITlaVl60I9Ab860O-nZsFbWydvU,11749
-bluecellulab-2.2.7.dist-info/METADATA,sha256=5WwQnAeKV2wAUVZc0O16ZbZjiqwiOxhP2uJwl3BrwXg,6907
-bluecellulab-2.2.7.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-bluecellulab-2.2.7.dist-info/top_level.txt,sha256=VSyEP8w9l3pXdRkyP_goeMwiNA8KWwitfAqUkveJkdQ,13
-bluecellulab-2.2.7.dist-info/RECORD,,
+bluecellulab-2.3.2.dist-info/AUTHORS.txt,sha256=EDs3H-2HXBojbma10psixk3C2rFiOCTIREi2ZAbXYNQ,179
+bluecellulab-2.3.2.dist-info/LICENSE,sha256=xOouu1gC1GGklDxkITlaVl60I9Ab860O-nZsFbWydvU,11749
+bluecellulab-2.3.2.dist-info/METADATA,sha256=1uZpRUUBcPBBCbAiudS3Qg3anmrygJBuNtQ_kTEC6O8,6907
+bluecellulab-2.3.2.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+bluecellulab-2.3.2.dist-info/top_level.txt,sha256=VSyEP8w9l3pXdRkyP_goeMwiNA8KWwitfAqUkveJkdQ,13
+bluecellulab-2.3.2.dist-info/RECORD,,