Merge branch 'master' into lfpy

Author: wvangeit

.github/workflows/test.yml

@@ -7,9 +7,11 @@ on:
 
 jobs:
   test:
-    runs-on: ubuntu-latest
+    name: Test for python ${{ matrix.python-version }} on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
     strategy:
       matrix:
+        os: [ubuntu-latest, macos-latest]
         python-version: ["3.7", "3.8", "3.9", "3.10"]
 
     steps:

bluepyopt/deapext/optimisations.py

@@ -199,7 +199,10 @@ def setup_deap(self):
 
         # Register the evaluation function for the individuals
         # import deap_efel_eval1
-        self.toolbox.register("evaluate", self.evaluator.evaluate_with_lists)
+        self.toolbox.register(
+            "evaluate",
+            self.evaluator.set_neuron_variables_and_evaluate_with_lists
+        )
 
         # Register the mate operator
         self.toolbox.register(

bluepyopt/deapext/optimisationsCMA.py

@@ -211,7 +211,10 @@ def setup_deap(self):
         )
 
         # Register the evaluation function for the individuals
-        self.toolbox.register("evaluate", self.evaluator.evaluate_with_lists)
+        self.toolbox.register(
+            "evaluate",
+            self.evaluator.set_neuron_variables_and_evaluate_with_lists
+        )
 
         import copyreg
         import types

bluepyopt/ephys/evaluators.py

@@ -216,6 +216,17 @@ def evaluate_with_lists(self, param_list=None, target='scores'):
 
         return self.objective_list(obj_dict)
 
+    def set_neuron_variables_and_evaluate_with_lists(
+        self, param_list=None, target='scores'
+    ):
+        """Set NEURON variables and run evaluation with lists.
+
+        Setting the NEURON variables is necessary when using ipyparallel,
+        since the new subprocesses have pristine NEURON.
+        """
+        self.sim.set_neuron_variables()
+        return self.evaluate_with_lists(param_list=param_list, target=target)
+
     def evaluate(self, param_list=None, target='scores'):
         """Run evaluation with lists as input and outputs"""
 

bluepyopt/ephys/protocols.py

@@ -258,12 +258,20 @@ def _reduce_method(meth):
             copyreg.pickle(types.MethodType, _reduce_method)
             import pebble
             from concurrent.futures import TimeoutError
+            import multiprocessing
+
+            # Default context for python>=3.8 on macos is spawn.
+            # Spwan context would reset NEURON properties, such as dt.
+            multiprocessing_context = multiprocessing.get_context('fork')
 
             if timeout is not None:
                 if timeout < 0:
                     raise ValueError("timeout should be > 0")
-
-            with pebble.ProcessPool(max_workers=1, max_tasks=1) as pool:
+            with pebble.ProcessPool(
+                max_workers=1,
+                max_tasks=1,
+                context=multiprocessing_context
+            ) as pool:
                 tasks = pool.schedule(self._run_func, kwargs={
                     'cell_model': cell_model,
                     'param_values': param_values,

bluepyopt/ephys/simulators.py

@@ -21,8 +21,8 @@ def __init__(self, dt=None, cvode_active=True, cvode_minstep=None,
         """Constructor
 
         Args:
-            dt (float): the integration time step used by neuron.
-            cvode_active (bool): should neuron use the variable time step
+            dt (float): the integration time step used by Neuron.
+            cvode_active (bool): should Neuron use the variable time step
                 integration method
             cvode_minstep (float): the minimum time step allowed for a cvode
                 step. Default is 0.0.
@@ -34,27 +34,21 @@ def __init__(self, dt=None, cvode_active=True, cvode_minstep=None,
                 "./data/".
         """
 
-        if platform.system() == 'Windows':
-            # hoc.so does not exist on NEURON Windows
-            # although \\hoc.pyd can work here, it gives an error for
-            # nrn_nobanner_ line
-            self.disable_banner = False
-            self.banner_disabled = False
-        else:
-            self.disable_banner = True
-            self.banner_disabled = False
-
+        # hoc.so does not exist on NEURON Windows or MacOS
+        # although \\hoc.pyd can work here, it gives an error for
+        # nrn_nobanner_ line
+        self.disable_banner = platform.system() not in ['Windows', 'Darwin']
+        self.banner_disabled = False
         self.mechanisms_directory = mechanisms_directory
-        self.neuron.h.load_file('stdrun.hoc')
 
         self.dt = dt if dt is not None else self.neuron.h.dt
-        self.neuron.h.dt = self.dt
 
-        self.neuron.h.cvode_active(1 if cvode_active else 0)
         self.cvode_minstep_value = cvode_minstep
 
         self.cvode_active = cvode_active
 
+        self.set_neuron_variables()
+
         self.random123_globalindex = random123_globalindex
 
     @property
@@ -93,11 +87,9 @@ def _nrn_disable_banner():
             ctypes.c_int.in_dll(nrndll, 'nrn_nobanner_').value = 1
 
     # pylint: disable=R0201
-    # TODO function below should probably a class property or something in that
-    # sense
     @property
     def neuron(self):
-        """Return neuron module"""
+        """Return Neuron module"""
 
         if self.disable_banner and not self.banner_disabled:
             NrnSimulator._nrn_disable_banner()
@@ -112,6 +104,12 @@ def neuron(self):
 
         return neuron
 
+    def set_neuron_variables(self):
+        """Set Neuron variables"""
+        self.neuron.h.load_file('stdrun.hoc')
+        self.neuron.h.dt = self.dt
+        self.neuron.h.cvode_active(1 if self.cvode_active else 0)
+
     def run(
             self,
             tstop=None,

bluepyopt/tests/test_ephys/test_protocols.py

@@ -365,6 +365,57 @@ def test_sweepprotocol_run_unisolated():
     dummy_cell.destroy(sim=nrn_sim)
 
 
+@pytest.mark.unit
+def test_sweepprotocol_run_isolated():
+    """ephys.protocols: Test SweepProtocol isolated run"""
+
+    nrn_sim = ephys.simulators.NrnSimulator(dt=0.1)
+    dummy_cell = dummycells.DummyCellModel1()
+    soma_loc = ephys.locations.NrnSeclistCompLocation(
+        name='soma_loc',
+        seclist_name='somatic',
+        sec_index=0,
+        comp_x=.5)
+    unknown_loc = ephys.locations.NrnSomaDistanceCompLocation(
+        name='unknown_loc',
+        seclist_name='somatic',
+        soma_distance=100)
+
+    rec_soma = ephys.recordings.CompRecording(
+        name='soma.v',
+        location=soma_loc,
+        variable='v')
+    rec_unknown = ephys.recordings.CompRecording(
+        name='unknown.v',
+        location=unknown_loc,
+        variable='v')
+
+    stim = ephys.stimuli.NrnSquarePulse(
+        step_amplitude=0.0,
+        step_delay=0.0,
+        step_duration=50,
+        total_duration=50,
+        location=soma_loc)
+
+    protocol = ephys.protocols.SweepProtocol(
+        name='prot',
+        stimuli=[stim],
+        recordings=[rec_soma, rec_unknown])
+
+    responses = protocol.run(
+        cell_model=dummy_cell,
+        param_values={},
+        sim=nrn_sim,
+        isolate=True)
+
+    assert 'soma.v' in responses
+    assert 'unknown.v' in responses
+    assert responses['unknown.v'] is None
+
+    protocol.destroy(sim=nrn_sim)
+    dummy_cell.destroy(sim=nrn_sim)
+
+
 @pytest.mark.unit
 def test_nrnsimulator_exception():
     """ephys.protocols: test if protocol raise nrn sim exception"""