Implement LFPy backend

bluepyopt/ephys/models.py

@@ -200,7 +200,6 @@ def create_empty_template(
                ''' % dict(template_name=template_name, objref_str=objref_str,
                           newseclist_str=newseclist_str,
                           create_str=create_str)
-
         return template
 
     @staticmethod
@@ -246,7 +245,8 @@ def instantiate(self, sim=None):
 
         if self.params is not None:
             for param in self.params.values():
-                param.instantiate(sim=sim, icell=self.icell)
+                param.instantiate(sim=sim, icell=self.icell,
+                                  params=self.params)
 
     def destroy(self, sim=None):  # pylint: disable=W0613
         """Destroy instantiated model in simulator"""
@@ -479,3 +479,307 @@ def load_hoc_template(sim, hoc_string):
                 'NEURON does not have template: ' + template_name
 
         return template_name
+
+
+class LFPyCellModel(Model):
+
+    """LFPy.Cell model class"""
+
+    def __init__(
+        self,
+        name,
+        morph=None,
+        mechs=None,
+        params=None,
+        dt=0.025,
+        v_init=-65.0,
+        gid=0,
+        seclist_names=None,
+        secarray_names=None,
+    ):
+        """Constructor
+
+        Args:
+            name (str): name of this object
+                        should be alphanumeric string, underscores are allowed,
+                        first char should be a letter
+            morph (Morphology):
+                underlying Morphology of the cell
+            mechs (list of Mechanisms):
+                Mechanisms associated with the cell
+            params (list of Parameters):
+                Parameters of the cell model
+            seclist_names (list of strings):
+                Names of the lists of sections
+            secarray_names (list of strings):
+                Names of the sections
+        """
+        super(LFPyCellModel, self).__init__(name)
+        self.check_name()
+        self.morphology = morph
+        self.mechanisms = mechs
+        self.params = collections.OrderedDict()
+        if params is not None:
+            for param in params:
+                self.params[param.name] = param
+
+        # Cell instantiation in simulator
+        self.icell = None
+        self.LFPyCell = None
+
+        self.dt = dt
+        self.v_init = v_init
+
+        self.param_values = None
+        self.gid = gid
+
+        if seclist_names is None:
+            self.seclist_names = [
+                "all",
+                "somatic",
+                "basal",
+                "apical",
+                "axonal",
+                "myelinated",
+            ]
+        else:
+            self.seclist_names = seclist_names
+
+        if secarray_names is None:
+            self.secarray_names = ["soma", "dend", "apic", "axon", "myelin"]
+        else:
+            self.secarray_names = secarray_names
+
+    def check_name(self):
+        """Check if name complies with requirements"""
+
+        allowed_chars = string.ascii_letters + string.digits + "_"
+
+        if sys.version_info[0] < 3:
+            translate_args = [None, allowed_chars]
+        else:
+            translate_args = [str.maketrans("", "", allowed_chars)]
+
+        if (
+            self.name == ""
+            or self.name[0] not in string.ascii_letters
+            or not str(self.name).translate(*translate_args) == ""
+        ):
+            raise TypeError(
+                'CellModel: name "%s" provided to constructor does not comply '
+                "with the rules for Neuron template name: name should be "
+                "alphanumeric "
+                "non-empty string, underscores are allowed, "
+                "first char should be letter" % self.name
+            )
+
+    def params_by_names(self, param_names):
+        """Get parameter objects by name"""
+
+        return [self.params[param_name] for param_name in param_names]
+
+    def freeze(self, param_dict):
+        """Set params"""
+
+        for param_name, param_value in param_dict.items():
+            self.params[param_name].freeze(param_dict[param_name])
+
+    def unfreeze(self, param_names):
+        """Unset params"""
+
+        for param_name in param_names:
+            self.params[param_name].unfreeze()
+
+    @staticmethod
+    def create_empty_template(
+        template_name, seclist_names=None, secarray_names=None
+    ):
+        """create an hoc template named template_name for an empty cell"""
+
+        objref_str = "objref this, CellRef"
+        newseclist_str = ""
+
+        if seclist_names:
+            for seclist_name in seclist_names:
+                objref_str += ", %s" % seclist_name
+                newseclist_str += (
+                    "             %s = new SectionList()\n" % seclist_name
+                )
+
+        create_str = ""
+        if secarray_names:
+            create_str = "create "
+            create_str += ", ".join(
+                "%s[1]" % secarray_name for secarray_name in secarray_names
+            )
+            create_str += "\n"
+
+        template = """\
+        begintemplate %(template_name)s
+          %(objref_str)s
+          proc init() {\n%(newseclist_str)s
+            forall delete_section()
+            CellRef = this
+          }
+
+          gid = 0
+
+          proc destroy() {localobj nil
+            CellRef = nil
+          }
+
+          %(create_str)s
+        endtemplate %(template_name)s
+               """ % dict(
+            template_name=template_name,
+            objref_str=objref_str,
+            newseclist_str=newseclist_str,
+            create_str=create_str,
+        )
+
+        return template
+
+    @staticmethod
+    def create_empty_cell(name, sim, seclist_names=None, secarray_names=None):
+        """Create an empty cell in Neuron"""
+
+        # TODO minize hardcoded definition
+        # E.g. sectionlist can be procedurally generated
+        hoc_template = CellModel.create_empty_template(
+            name, seclist_names, secarray_names
+        )
+        sim.neuron.h(hoc_template)
+
+        template_function = getattr(sim.neuron.h, name)
+
+        return template_function()
+
+    def instantiate(self, sim=None):
+        """Instantiate model in simulator"""
+        import LFPy
+
+        # TODO replace this with the real template name
+        if not hasattr(sim.neuron.h, self.name):
+            self.icell = self.create_empty_cell(
+                self.name,
+                sim=sim,
+                seclist_names=self.seclist_names,
+                secarray_names=self.secarray_names,
+            )
+        else:
+            self.icell = getattr(sim.neuron.h, self.name)()
+
+        self.icell.gid = self.gid
+
+        self.morphology.instantiate(sim=sim, icell=self.icell)
+
+        self.LFPyCell = LFPy.Cell(
+            morphology=sim.neuron.h.allsec(),
+            dt=self.dt,
+            v_init=self.v_init,
+            pt3d=True,
+            delete_sections=False,
+            nsegs_method=None,
+        )
+
+        if self.mechanisms is not None:
+            for mechanism in self.mechanisms:
+                mechanism.instantiate(sim=sim, icell=self.icell)
+
+        if self.params is not None:
+            for param in self.params.values():
+                param.instantiate(sim=sim, icell=self.icell,
+                                  params=self.params)
+
+    def destroy(self, sim=None):  # pylint: disable=W0613
+        """Destroy instantiated model in simulator"""
+
+        # Make sure the icell's destroy() method is called
+        # without it a circular reference exists between CellRef and the object
+        # this prevents the icells from being garbage collected, and
+        # cell objects pile up in the simulator
+        self.icell.destroy()
+
+        # The line below is some M. Hines magic
+        # DON'T remove it, because it will make sure garbage collection
+        # is called on the icell object
+        sim.neuron.h.Vector().size()
+
+        self.icell = None
+
+        self.morphology.destroy(sim=sim)
+        for mechanism in self.mechanisms:
+            mechanism.destroy(sim=sim)
+        for param in self.params.values():
+            param.destroy(sim=sim)
+
+    def check_nonfrozen_params(self, param_names):  # pylint: disable=W0613
+        """Check if all nonfrozen params are set"""
+
+        for param_name, param in self.params.items():
+            if not param.frozen:
+                raise Exception(
+                    "CellModel: Nonfrozen param %s needs to be "
+                    "set before simulation" % param_name
+                )
+
+    def create_hoc(
+        self,
+        param_values,
+        ignored_globals=(),
+        template="cell_template.jinja2",
+        disable_banner=False,
+        template_dir=None,
+    ):
+        """Create hoc code for this model"""
+
+        to_unfreeze = []
+        for param in self.params.values():
+            if not param.frozen:
+                param.freeze(param_values[param.name])
+                to_unfreeze.append(param.name)
+
+        template_name = self.name
+        morphology = os.path.basename(self.morphology.morphology_path)
+        if self.morphology.do_replace_axon:
+            replace_axon = self.morphology.replace_axon_hoc
+        else:
+            replace_axon = None
+
+        ret = create_hoc.create_hoc(
+            mechs=self.mechanisms,
+            parameters=self.params.values(),
+            morphology=morphology,
+            ignored_globals=ignored_globals,
+            replace_axon=replace_axon,
+            template_name=template_name,
+            template_filename=template,
+            template_dir=template_dir,
+            disable_banner=disable_banner,
+        )
+
+        self.unfreeze(to_unfreeze)
+
+        return ret
+
+    def __str__(self):
+        """Return string representation"""
+
+        content = "%s:\n" % self.name
+
+        content += "  morphology:\n"
+
+        if self.morphology is not None:
+            content += "    %s\n" % str(self.morphology)
+
+        content += "  mechanisms:\n"
+        if self.mechanisms is not None:
+            for mechanism in self.mechanisms:
+                content += "    %s\n" % mechanism
+
+        content += "  params:\n"
+        if self.params is not None:
+            for param in self.params.values():
+                content += "    %s\n" % param
+
+        return content

bluepyopt/ephys/morphologies.py

@@ -42,7 +42,9 @@ class NrnFileMorphology(Morphology, DictMixin):
 
     """Morphology loaded from a file"""
     SERIALIZED_FIELDS = ('morphology_path', 'do_replace_axon', 'do_set_nseg',
-                         'replace_axon_hoc', )
+                         'replace_axon_hoc', 'nseg_frequency',
+                         'morph_modifiers', 'morph_modifiers_hoc',
+                         'morph_modifiers_kwargs')
 
     def __init__(
             self,
@@ -53,7 +55,8 @@ def __init__(
             replace_axon_hoc=None,
             nseg_frequency=40,
             morph_modifiers=None,
-            morph_modifiers_hoc=None):
+            morph_modifiers_hoc=None,
+            morph_modifiers_kwargs=None):
         """Constructor
 
         Args:
@@ -73,6 +76,7 @@ def __init__(
                 with (sim, icell) as arguments
             morph_modifiers_hoc (list): list of hoc strings corresponding
                 to morph_modifiers
+            morph_modifiers_kwargs (dict): kwargs for morph_modifiers functions
         """
         name = os.path.basename(morphology_path)
         super(NrnFileMorphology, self).__init__(name=name, comment=comment)
@@ -84,6 +88,9 @@ def __init__(
         self.nseg_frequency = nseg_frequency
         self.morph_modifiers = morph_modifiers
         self.morph_modifiers_hoc = morph_modifiers_hoc
+        self.morph_modifiers_kwargs = morph_modifiers_kwargs
+        if self.morph_modifiers_kwargs is None:
+            self.morph_modifiers_kwargs = {}
 
         if replace_axon_hoc is None:
             self.replace_axon_hoc = self.default_replace_axon_hoc
@@ -146,7 +153,8 @@ def instantiate(self, sim=None, icell=None):
 
         if self.morph_modifiers is not None:
             for morph_modifier in self.morph_modifiers:
-                morph_modifier(sim=sim, icell=icell)
+                morph_modifier(sim=sim, icell=icell,
+                               **self.morph_modifiers_kwargs)
 
     def destroy(self, sim=None):
         """Destroy morphology instantiation"""