Merge pull request #31 from alejoe91/cleaning

Some refactoring

Author: alejoe91

bluepyopt/ephys/extra_features_utils.py

@@ -341,7 +341,7 @@ def recovery_slope(waveforms, sampling_frequency, window):
     time = np.arange(0, waveforms.shape[1]) * (1 / sampling_frequency)  # in s
 
     for i in range(waveforms.shape[0]):
-        if peak_idx[i] == 0 or peak_idx[i] == waveforms.shape[1]:
+        if peak_idx[i] in [0, waveforms.shape[1]]:
             continue
         max_idx = int(peak_idx[i] + ((window / 1000) * sampling_frequency))
         max_idx = np.min([max_idx, waveforms.shape[1]])

bluepyopt/ephys/models.py

@@ -488,6 +488,7 @@ class LFPyCellModel(Model):
     def __init__(
         self,
         name,
+        electrode=None,
         morph=None,
         mechs=None,
         params=None,
@@ -525,7 +526,9 @@ def __init__(
 
         # Cell instantiation in simulator
         self.icell = None
-        self.LFPyCell = None
+        self.lfpy_cell = None
+        self.electrode = electrode
+        self.lfpy_electrode = None
 
         self.dt = dt
         self.v_init = v_init
@@ -656,7 +659,8 @@ def create_empty_cell(name, sim, seclist_names=None, secarray_names=None):
 
     def instantiate(self, sim=None):
         """Instantiate model in simulator"""
-        import LFPy
+        from LFPy import Cell
+        from lfpykit import RecExtElectrode
 
         # TODO replace this with the real template name
         if not hasattr(sim.neuron.h, self.name):
@@ -673,7 +677,7 @@ def instantiate(self, sim=None):
 
         self.morphology.instantiate(sim=sim, icell=self.icell)
 
-        self.LFPyCell = LFPy.Cell(
+        self.lfpy_cell = Cell(
             morphology=sim.neuron.h.allsec(),
             dt=self.dt,
             v_init=self.v_init,
@@ -682,6 +686,10 @@ def instantiate(self, sim=None):
             nsegs_method=None,
         )
 
+        self.lfpy_electrode = RecExtElectrode(
+            self.lfpy_cell, probe=self.electrode
+        )
+
         if self.mechanisms is not None:
             for mechanism in self.mechanisms:
                 mechanism.instantiate(sim=sim, icell=self.icell)

bluepyopt/ephys/parameters.py

@@ -196,7 +196,7 @@ def __init__(
             value_scaler (float): value used to scale the parameter value
             locations (list of ephys.locations.Location): locations on which
                 to instantiate the parameter
-            param_dependencies (list): dependencies needed to intantiate
+            param_dependencies (list): dependencies needed to instantiate
                 the parameter
         """
 

bluepyopt/ephys/protocols.py

@@ -1,4 +1,7 @@
 """Protocol classes"""
+from .recordings import LFPRecording
+from .simulators import LFPySimulator
+from .stimuli import LFPStimulus
 
 """
 Copyright (c) 2016-2020, EPFL/Blue Brain Project
@@ -193,23 +196,19 @@ def _run_func(self, cell_model, param_values, sim=None):
             cell_model.freeze(param_values)
             cell_model.instantiate(sim=sim)
 
-            if isinstance(cell_model, models.LFPyCellModel):
-                LFPyCell = cell_model.LFPyCell
-            else:
-                LFPyCell = None
-
-            self.instantiate(
-                sim=sim, icell=cell_model.icell, LFPyCell=LFPyCell
-            )
-
-            if hasattr(sim, "electrode"):
-                if any(["LFP" in rec.name for rec in self.recordings]):
-                    sim.effective_electrode = sim.electrode
-                else:
-                    sim.effective_electrode = None
+            self.instantiate(sim=sim, cell_model=cell_model)
 
             try:
-                sim.run(self.total_duration, cvode_active=self.cvode_active)
+                if isinstance(sim, LFPySimulator):
+                    sim.run(
+                        lfpy_cell=cell_model.lfpy_cell,
+                        lfpy_electrode=cell_model.lfpy_electrode,
+                        tstop=self.total_duration,
+                        cvode_active=self.cvode_active)
+                else:
+                    sim.run(
+                        self.total_duration, cvode_active=self.cvode_active
+                    )
             except (RuntimeError, simulators.NrnSimulatorException):
                 logger.debug(
                     'SweepProtocol: Running of parameter set {%s} generated '
@@ -284,23 +283,23 @@ def _reduce_method(meth):
                                        sim=sim)
         return responses
 
-    def instantiate(self, sim=None, icell=None, LFPyCell=None):
+    def instantiate(self, sim=None, cell_model=None):
         """Instantiate"""
 
         for stimulus in self.stimuli:
-            if LFPyCell is not None:
-                stimulus.instantiate(sim=sim, icell=icell, LFPyCell=LFPyCell)
+            if isinstance(stimulus, LFPStimulus):
+                stimulus.instantiate(lfpy_cell=cell_model.lfpy_cell)
             else:
-                stimulus.instantiate(sim=sim, icell=icell)
+                stimulus.instantiate(sim=sim, icell=cell_model.icell)
 
         for recording in self.recordings:
             try:
-                # try to instantiate as an LFPy recording
-                try:
-                    recording.instantiate(sim=sim, icell=icell,
-                                          LFPyCell=LFPyCell)
-                except Exception as e:
-                    recording.instantiate(sim=sim, icell=icell)
+                if isinstance(recording, LFPRecording):
+                    recording.instantiate(sim=sim,
+                                          lfpy_cell=cell_model.lfpy_cell,
+                                          electrode=cell_model.lfpy_electrode)
+                else:
+                    recording.instantiate(sim=sim, icell=cell_model.icell)
             except locations.EPhysLocInstantiateException:
                 logger.debug(
                     'SweepProtocol: Instantiating recording generated '

bluepyopt/ephys/recordings.py

@@ -141,10 +141,10 @@ def response(self):
             return None
         self.tvector = self.cell.tvec
         return responses.TimeLFPResponse(
-            self.name, self.tvector, self.sim.lfpyelectrode.data
+            self.name, self.tvector, self.electrode.data
         )
 
-    def instantiate(self, sim=None, icell=None, LFPyCell=None):
+    def instantiate(self, sim=None, lfpy_cell=None, electrode=None):
         import LFPy
 
         """Instantiate recording"""
@@ -154,10 +154,11 @@ def instantiate(self, sim=None, icell=None, LFPyCell=None):
         )
 
         assert isinstance(
-            LFPyCell, LFPy.Cell
+            lfpy_cell, LFPy.Cell
         ), "LFPRecording is only available for LFPCellModel"
-        self.cell = LFPyCell
+        self.cell = lfpy_cell
         self.tvector = None
+        self.electrode = electrode
         self.sim = sim
 
         self.instantiated = True
@@ -168,7 +169,8 @@ def destroy(self, sim=None):
         self.electrode = None
         self.LFP = None
         self.tvector = None
-
+        self.electrode = None
+        self.cell = None
         self.instantiated = False
 
     def __str__(self):

bluepyopt/ephys/responses.py

@@ -86,35 +86,22 @@ def plot(self, axes):
             self.name)
 
 
-class TimeLFPResponse(Response):
+class TimeLFPResponse(TimeVoltageResponse):
 
     """Response to stimulus"""
 
-    def __init__(self, name, time=None, LFP=None):
+    def __init__(self, name, time=None, lfp=None):
         """Constructor
         Args:
             name (str): name of this object
             time (list of floats): time series
-            LFP (list of floats): voltage series
+            lfp (list of floats): voltage series
         """
 
-        super(TimeLFPResponse, self).__init__(name)
-
+        super(TimeLFPResponse, self).__init__(name, time=time, voltage=None)
         self.response = {}
         self.response["time"] = time
-        self.response["voltage"] = LFP
-
-    def read_csv(self, filename):
-        """Load response from csv file"""
-
-        self.response = pandas.read_csv(filename)
-
-    def to_csv(self, filename):
-        """Write response to csv file"""
-
-        self.response.to_csv(filename)
-
-    def __getitem__(self, index):
-        """Return item at index"""
+        self.response["voltage"] = lfp
 
-        return self.response.__getitem__(index)
+    def plot(self, axes):
+        raise NotImplementedError

bluepyopt/ephys/simulators.py

@@ -184,18 +184,16 @@ def __init__(self, message, original):
         self.original = original
 
 
-class LFPySimulator(object):
+class LFPySimulator(NrnSimulator):
 
     """LFPy simulator"""
 
-    def __init__(self, LFPyCellModel, electrode=None, cvode_active=True,
-                 cvode_minstep=None, random123_globalindex=None,
-                 mechanisms_directory=None):
+    def __init__(self, dt=None, cvode_active=True, cvode_minstep=None,
+                 random123_globalindex=None, mechanisms_directory=None):
         """Constructor
+
         Args:
-            LFPyCellModel (LFPyCellModel): the LFPy cell model
-            electrode (MEAutility.MEA): the MEAutility probe used to compute
-                extracellular signals
+            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
@@ -208,81 +206,30 @@ def __init__(self, LFPyCellModel, electrode=None, cvode_active=True,
                 "./data/".
         """
 
-        self.LFPyCellModel = LFPyCellModel
-        self.electrode = electrode
-        self.effective_electrode = electrode
-
-        self.lfpyelectrode = None
-
-        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
-
-        self.mechanisms_directory = mechanisms_directory
-        self.neuron.h.load_file('stdrun.hoc')
-
-        self.cvode_active = cvode_active
-        self.cvode_minstep_value = cvode_minstep
-
-        self.random123_globalindex = random123_globalindex
-
-    @staticmethod
-    def _nrn_disable_banner():
-        """Disable Neuron banner"""
-
-        nrnpy_path = os.path.join(imp.find_module("neuron")[1])
-        import glob
-
-        hoc_so_list = glob.glob(os.path.join(nrnpy_path, "hoc*.so"))
-
-        if len(hoc_so_list) != 1:
-            warnings.warn(
-                "Unable to find Neuron hoc shared library in %s, "
-                "not disabling banner" % nrnpy_path
-            )
-        else:
-            hoc_so = hoc_so_list[0]
-            nrndll = ctypes.cdll[hoc_so]
-            ctypes.c_int.in_dll(nrndll, "nrn_nobanner_").value = 1
-
-    @property
-    def neuron(self):
-        """Return neuron module"""
-
-        if self.disable_banner and not self.banner_disabled:
-            NrnSimulator._nrn_disable_banner()
-            self.banner_disabled = True
-
-        import neuron  # NOQA
-        if self.mechanisms_directory is not None:
-            neuron.load_mechanisms(
-                self.mechanisms_directory, warn_if_already_loaded=False
-            )
-
-        return neuron
+        super(LFPySimulator, self).__init__(
+            dt=dt,
+            cvode_active=cvode_active,
+            cvode_minstep=cvode_minstep,
+            random123_globalindex=random123_globalindex,
+            mechanisms_directory=mechanisms_directory
+        )
 
     def run(
             self,
+            lfpy_cell,
+            lfpy_electrode,
             tstop=None,
             dt=None,
             cvode_active=None,
             random123_globalindex=None):
         """Run protocol"""
-        import LFPy
-        # import neuron mechanisms
         _ = self.neuron
 
-        self.LFPyCellModel.LFPyCell.tstart = 0.0
-        self.LFPyCellModel.LFPyCell.tstop = tstop
+        lfpy_cell.tstart = 0.0
+        lfpy_cell.tstop = tstop
 
         if dt is not None:
-            self.LFPyCellModel.LFPyCell.dt = dt
+            lfpy_cell.dt = dt
 
         if cvode_active and dt is not None:
             raise ValueError(
@@ -302,12 +249,7 @@ def run(
             rng = self.neuron.h.Random()
             rng.Random123_globalindex(random123_globalindex)
 
-        if self.effective_electrode is not None:
-            self.lfpyelectrode = LFPy.RecExtElectrode(
-                self.LFPyCellModel.LFPyCell, probe=self.electrode)
-            probes = [self.lfpyelectrode]
-        else:
-            probes = None
+        probes = [lfpy_electrode] if lfpy_electrode is not None else None
 
         sim_params = {
             "probes": probes,
@@ -324,7 +266,7 @@ def run(
         }
 
         try:
-            self.LFPyCellModel.LFPyCell.simulate(**sim_params)
+            lfpy_cell.simulate(**sim_params)
         except Exception as e:
             raise LFPySimulatorException("LFPy simulator error", e)