STDP synapse and IAF neuron generation for the compartmental feature [WIP]

doc/running/running_nest_compartmental.rst

@@ -79,7 +79,7 @@ As an example for a HH-type channel:
 
 All of the currents within a compartment (marked by ``@mechanism::channel``) are added up within a compartment.
 
-For a complete example, please see `cm_default.nestml <https://github.com/nest/nestml/blob/master/tests/nest_compartmental_tests/resources/concmech.nestml>`_ and its associated unit test, `compartmental_model_test.py <https://github.com/nest/nestml/blob/master/tests/nest_compartmental_tests/concmech_model_test.py>`_.
+For a complete example, please see `cm_default.nestml <https://github.com/nest/nestml/blob/master/tests/nest_compartmental_tests/resources/concmech.nestml>`_ and its associated unit test, `test__compartmental_model.py <https://github.com/nest/nestml/blob/master/tests/nest_compartmental_tests/test__concmech_model.py>`_.
 
 
 Concentration description
@@ -111,12 +111,14 @@ As an example a description of a calcium concentration model where we pretend th
 
 The only difference here is that the equation that is marked with the ``@mechanism::concentration`` descriptor is not an inline equation but an ODE. This is because in case of the ion-channel what we want to simulate is the current which relies on the evolution of some state variables like gating variables in case of the HH-models, and the compartment voltage. The concentration though can be more simply described by an evolving state directly.
 
-For a complete example, please see `concmech.nestml <https://github.com/nest/nestml/blob/master/tests/nest_compartmental_tests/resources/concmech.nestml>`_ and its associated unit test, `compartmental_model_test.py <https://github.com/nest/nestml/blob/master/tests/nest_compartmental_tests/concmech_model_test.py>`_.
+For a complete example, please see `concmech.nestml <https://github.com/nest/nestml/blob/master/tests/nest_compartmental_tests/resources/concmech.nestml>`_ and its associated unit test, `test__concmech_model.py <https://github.com/nest/nestml/blob/master/tests/nest_compartmental_tests/test__concmech_model.py>`_.
 
 Synapse description
 -------------------
 
-Here synapse models are based on convolutions over a buffer of incoming spikes. This means that the equation for the current-contribution must contain a convolve() call and a description of the kernel used for that convolution is needed. The descriptor for synapses is ``@mechanism::receptor``.
+Here synapse models are based on convolutions over a buffer of incoming spikes. This means that the equation for the
+current-contribution must contain a convolve() call and a description of the kernel used for that convolution is needed.
+The descriptor for synapses is ``@mechanism::receptor``.
 
 .. code-block:: nestml
 
@@ -133,13 +135,44 @@ Here synapse models are based on convolutions over a buffer of incoming spikes.
         input:
             <spike_name> <- spike
 
-For a complete example, please see `concmech.nestml <https://github.com/nest/nestml/blob/master/tests/nest_compartmental_tests/resources/concmech.nestml>`_ and its associated unit test, `compartmental_model_test.py <https://github.com/nest/nestml/blob/master/tests/nest_compartmental_tests/concmech_model_test.py>`_.
+For a complete example, please see `concmech.nestml <https://github.com/nest/nestml/blob/master/tests/nest_compartmental_tests/resources/concmech.nestml>`_ and its associated unit test, `test__concmech_model.py <https://github.com/nest/nestml/blob/master/tests/nest_compartmental_tests/test__concmech_model.py>`_.
+
+Continuous input description
+----------------------------
+
+The continuous inputs are defined by an inline with the descriptor @mechanism::continuous_input. This inline needs to
+include one input of type continuous and may include any states, parameters and functions.
+
+.. code-block:: nestml
+
+    model <neuron_name>:
+            equations:
+                inline <current_equation_name> real = \
+                    <some equation based on state variables, parameters, membrane potential and other equation names \
+                    and MUST contain at least one reference to a continuous input port like <continuous_name>> \
+                    @mechanism::continuous_input
+
+            input:
+                <continuous_name> real <- continuous
+
+For a complete example, please see `continuous_test.nestml <https://github.com/nest/nestml/blob/master/tests/nest_compartmental_tests/resources/continuous_test.nestml>`_ and its associated unit test, `test__continuous_input.py <https://github.com/nest/nestml/blob/master/tests/nest_compartmental_tests/test__continuous_input.py>`_.
 
 Mechanism interdependence
 -------------------------
 
 Above examples of explicit interdependence inbetween concentration and channel models where already described. Note that it is not necessary to describe the basic interaction inherent through the contribution to the overall current of the compartment. During a simulation step all currents of channels and synapses are added up and contribute to the change of the membrane potential (v_comp) in the next timestep. Thereby one must only express a dependence explicitly if the mechanism depends on the activity of a specific channel- or synapse-type amongst multiple in a given compartment or some concentration.
 
+Technical Notes
+---------------
+
+We have put emphasis on delivering a good performance for neurons with high spacial complexity. We utilize vectorization
+therefor you should compile nest with the OpenMP flag enabled. This of course can only be utilized if your hardware
+supports simd instructions in that case you can expect a performance improvement of about 3/4 of the theoretical improvement.
+Let's say you have an avx2 simd instruction set available you can expect about a 3 times performance improvement as long
+as your neuron has enough compartments.
+We vectorize the simulation steps of all instances of the same mechanism you have defined in
+your nestml model, meaning that you will get a better complexity/performance ratio the more instances of the same
+mechanism are used.
 
 See also
 --------

extras/convert_cm_default_to_template.py

@@ -37,7 +37,7 @@ def get_replacement_patterns():
         # file names
         'cm_default'            : '{{neuronSpecificFileNamesCmSyns[\"main\"]}}',
         'cm_tree'               : '{{neuronSpecificFileNamesCmSyns[\"tree\"]}}',
-        'cm_compartmentcurrents': '{{neuronSpecificFileNamesCmSyns[\"compartmentcurrents\"]}}',
+        'cm_neuroncurrents': '{{neuronSpecificFileNamesCmSyns[\"neuroncurrents\"]}}',
         # class names
         'CompTree'              : 'CompTree{{cm_unique_suffix}}',
         'Compartment'           : 'Compartment{{cm_unique_suffix}}',

pynestml/cocos/co_co_cm_continuous_input_model.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+#
+# co_co_cm_continuous_input_model.py
+#
+# This file is part of NEST.
+#
+# Copyright (C) 2004 The NEST Initiative
+#
+# NEST is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#
+# NEST is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with NEST.  If not, see <http://www.gnu.org/licenses/>.
+
+from pynestml.cocos.co_co import CoCo
+from pynestml.meta_model.ast_model import ASTModel
+from pynestml.utils.continuous_input_processing import ContinuousInputProcessing
+
+
+class CoCoCmContinuousInputModel(CoCo):
+    @classmethod
+    def check_co_co(cls, neuron: ASTModel):
+        """
+        Checks if this compartmental condition applies to the handed over neuron.
+        If yes, it checks the presence of expected functions and declarations.
+        :param neuron: a single neuron instance.
+        :type neuron: ast_neuron
+        """
+        return ContinuousInputProcessing.check_co_co(neuron)

pynestml/cocos/co_co_cm_synapse_model.py

@@ -21,7 +21,7 @@
 
 from pynestml.cocos.co_co import CoCo
 from pynestml.meta_model.ast_model import ASTModel
-from pynestml.utils.synapse_processing import SynapseProcessing
+from pynestml.utils.receptor_processing import ReceptorProcessing
 
 
 class CoCoCmSynapseModel(CoCo):
@@ -33,4 +33,4 @@ def check_co_co(cls, model: ASTModel):
         If yes, it checks the presence of expected functions and declarations.
         :param model: a single neuron instance.
         """
-        return SynapseProcessing.check_co_co(model)
+        return ReceptorProcessing.check_co_co(model)

pynestml/cocos/co_co_v_comp_exists.py

@@ -26,6 +26,8 @@
 from pynestml.utils.messages import Messages
 from pynestml.utils.logger import Logger, LoggingLevel
 
+import traceback
+
 
 class CoCoVCompDefined(CoCo):
     """
@@ -48,10 +50,14 @@ def check_co_co(cls, neuron: ASTModel):
             If True, checks are not as rigorous. Use False where possible.
         """
         from pynestml.codegeneration.nest_compartmental_code_generator import NESTCompartmentalCodeGenerator
+        from pynestml.codegeneration.code_generator_utils import CodeGeneratorUtils
 
         if not FrontendConfiguration.get_target_platform().upper() == 'NEST_COMPARTMENTAL':
             return
 
+        if not isinstance(neuron, ASTModel):
+            return
+
         enforced_variable_name = NESTCompartmentalCodeGenerator._default_options["compartmental_variable_name"]
 
         state_blocks = neuron.get_state_blocks()
@@ -62,6 +68,18 @@ def check_co_co(cls, neuron: ASTModel):
         if isinstance(state_blocks, ASTBlockWithVariables):
             state_blocks = [state_blocks]
 
+        stack = traceback.extract_stack()
+        formatted = ''.join(traceback.format_list(stack))
+        print("Traceback: \n" + formatted)
+        print("Neuron name: " + neuron.name)
+        print("State names: ")
+        for state_block in state_blocks:
+            declarations = state_block.get_declarations()
+            for declaration in declarations:
+                variables = declaration.get_variables()
+                for variable in variables:
+                    variable_name = variable.get_name().lower().strip()
+                    print(variable_name)
         for state_block in state_blocks:
             declarations = state_block.get_declarations()
             for declaration in declarations:
@@ -72,9 +90,11 @@ def check_co_co(cls, neuron: ASTModel):
                         return True
 
         cls.log_error(neuron, state_blocks[0].get_source_position(), enforced_variable_name)
+        breakpoint()
         return False
 
     @classmethod
     def log_error(cls, neuron: ASTModel, error_position, missing_variable_name):
         code, message = Messages.get_v_comp_variable_value_missing(neuron.get_name(), missing_variable_name)
-        Logger.log_message(error_position=error_position, node=neuron, log_level=LoggingLevel.ERROR, code=code, message=message)
+        Logger.log_message(error_position=error_position, node=neuron, log_level=LoggingLevel.ERROR, code=code,
+                           message=message)

pynestml/cocos/co_cos_manager.py

@@ -25,6 +25,7 @@
 from pynestml.cocos.co_co_inline_expression_not_assigned_to import CoCoInlineExpressionNotAssignedTo
 from pynestml.cocos.co_co_input_port_not_assigned_to import CoCoInputPortNotAssignedTo
 from pynestml.cocos.co_co_cm_channel_model import CoCoCmChannelModel
+from pynestml.cocos.co_co_cm_continuous_input_model import CoCoCmContinuousInputModel
 from pynestml.cocos.co_co_convolve_cond_correctly_built import CoCoConvolveCondCorrectlyBuilt
 from pynestml.cocos.co_co_convolve_has_correct_parameter import CoCoConvolveHasCorrectParameter
 from pynestml.cocos.co_co_input_port_not_assigned_to import CoCoInputPortNotAssignedTo
@@ -148,6 +149,7 @@ def check_compartmental_model(cls, neuron: ASTModel) -> None:
         CoCoCmChannelModel.check_co_co(neuron)
         CoCoCmConcentrationModel.check_co_co(neuron)
         CoCoCmSynapseModel.check_co_co(neuron)
+        CoCoCmContinuousInputModel.check_co_co(neuron)
 
     @classmethod
     def check_inline_expressions_have_rhs(cls, model: ASTModel):
@@ -413,7 +415,7 @@ def post_symbol_table_builder_checks(cls, model: ASTModel, after_ast_rewrite: bo
         cls.check_variables_defined_before_usage(model, after_ast_rewrite)
         if FrontendConfiguration.get_target_platform().upper() == 'NEST_COMPARTMENTAL':
             # XXX: TODO: refactor this out; define a ``cocos_from_target_name()`` in the frontend instead.
-            cls.check_v_comp_requirement(model)
+            # cls.check_v_comp_requirement(model)
             cls.check_compartmental_model(model)
         cls.check_inline_expressions_have_rhs(model)
         cls.check_inline_has_max_one_lhs(model)

pynestml/codegeneration/builder.py

@@ -91,4 +91,5 @@ def set_options(self, options: Mapping[str, Any]) -> Mapping[str, Any]:
         ret = super().set_options(options)
         ret.pop("redirect_build_output", None)
         ret.pop("build_output_dir", None)
+        ret.pop("fastexp", None)
         return ret

pynestml/codegeneration/nest_code_generator.py

@@ -611,7 +611,6 @@ def _get_neuron_model_namespace(self, neuron: ASTModel) -> Dict:
         :return: a map from name to functionality.
         """
         namespace = self._get_model_namespace(neuron)
-
         if "paired_synapse" in dir(neuron):
             namespace["extra_on_emit_spike_stmts_from_synapse"] = neuron.extra_on_emit_spike_stmts_from_synapse
             namespace["paired_synapse"] = neuron.paired_synapse.get_name()